diff --git a/assets/images/oneks/dark/create_k8s_cluster_1.png b/assets/images/oneks/dark/create_k8s_cluster_1.png new file mode 100644 index 000000000..357c8dd11 Binary files /dev/null and b/assets/images/oneks/dark/create_k8s_cluster_1.png differ diff --git a/assets/images/oneks/dark/create_k8s_cluster_2.png b/assets/images/oneks/dark/create_k8s_cluster_2.png new file mode 100644 index 000000000..de3730ea3 Binary files /dev/null and b/assets/images/oneks/dark/create_k8s_cluster_2.png differ diff --git a/assets/images/oneks/dark/create_k8s_cluster_3.png b/assets/images/oneks/dark/create_k8s_cluster_3.png new file mode 100644 index 000000000..7cb20b0b1 Binary files /dev/null and b/assets/images/oneks/dark/create_k8s_cluster_3.png differ diff --git a/assets/images/oneks/dark/create_k8s_cluster_4.png b/assets/images/oneks/dark/create_k8s_cluster_4.png new file mode 100644 index 000000000..e81832815 Binary files /dev/null and b/assets/images/oneks/dark/create_k8s_cluster_4.png differ diff --git a/assets/images/oneks/dark/create_k8s_cluster_flavours.png b/assets/images/oneks/dark/create_k8s_cluster_flavours.png new file mode 100644 index 000000000..09e543660 Binary files /dev/null and b/assets/images/oneks/dark/create_k8s_cluster_flavours.png differ diff --git a/assets/images/oneks/dark/create_k8s_cluster_version.png b/assets/images/oneks/dark/create_k8s_cluster_version.png new file mode 100644 index 000000000..7ba7d0d88 Binary files /dev/null and b/assets/images/oneks/dark/create_k8s_cluster_version.png differ diff --git a/assets/images/oneks/dark/create_k8s_logs_running.png b/assets/images/oneks/dark/create_k8s_logs_running.png new file mode 100644 index 000000000..2d44034ed Binary files /dev/null and b/assets/images/oneks/dark/create_k8s_logs_running.png differ diff --git a/assets/images/oneks/dark/k8s_add_node_group.png b/assets/images/oneks/dark/k8s_add_node_group.png new file mode 100644 index 000000000..0ccd028f3 Binary files /dev/null and b/assets/images/oneks/dark/k8s_add_node_group.png differ diff --git a/assets/images/oneks/dark/k8s_choose_flavours.png b/assets/images/oneks/dark/k8s_choose_flavours.png new file mode 100644 index 000000000..537408e70 Binary files /dev/null and b/assets/images/oneks/dark/k8s_choose_flavours.png differ diff --git a/assets/images/oneks/dark/k8s_kubeconfig.png b/assets/images/oneks/dark/k8s_kubeconfig.png new file mode 100644 index 000000000..7acb1ef88 Binary files /dev/null and b/assets/images/oneks/dark/k8s_kubeconfig.png differ diff --git a/assets/images/oneks/dark/k8s_logs_adding_node_group.png b/assets/images/oneks/dark/k8s_logs_adding_node_group.png new file mode 100644 index 000000000..4c2962d68 Binary files /dev/null and b/assets/images/oneks/dark/k8s_logs_adding_node_group.png differ diff --git a/assets/images/oneks/dark/k8s_logs_creating.png b/assets/images/oneks/dark/k8s_logs_creating.png new file mode 100644 index 000000000..3211a04ab Binary files /dev/null and b/assets/images/oneks/dark/k8s_logs_creating.png differ diff --git a/assets/images/oneks/dark/k8s_node_group_name.png b/assets/images/oneks/dark/k8s_node_group_name.png new file mode 100644 index 000000000..b3fa04d9a Binary files /dev/null and b/assets/images/oneks/dark/k8s_node_group_name.png differ diff --git a/assets/images/oneks/dark/k8s_recover_nodegroup_sunstone.png b/assets/images/oneks/dark/k8s_recover_nodegroup_sunstone.png new file mode 100644 index 000000000..6910a0713 Binary files /dev/null and b/assets/images/oneks/dark/k8s_recover_nodegroup_sunstone.png differ diff --git a/assets/images/oneks/dark/k8s_upgrade_cluster_sunstone.png b/assets/images/oneks/dark/k8s_upgrade_cluster_sunstone.png new file mode 100644 index 000000000..62d6a3221 Binary files /dev/null and b/assets/images/oneks/dark/k8s_upgrade_cluster_sunstone.png differ diff --git a/assets/images/oneks/dark/k8s_user_inputs.png b/assets/images/oneks/dark/k8s_user_inputs.png new file mode 100644 index 000000000..ec917b952 Binary files /dev/null and b/assets/images/oneks/dark/k8s_user_inputs.png differ diff --git a/assets/images/oneks/light/create_k8s_cluster_1.png b/assets/images/oneks/light/create_k8s_cluster_1.png index 883259a1e..c61a6c893 100644 Binary files a/assets/images/oneks/light/create_k8s_cluster_1.png and b/assets/images/oneks/light/create_k8s_cluster_1.png differ diff --git a/assets/images/oneks/light/create_k8s_cluster_2.png b/assets/images/oneks/light/create_k8s_cluster_2.png index 4745b912f..f8a3e39ce 100644 Binary files a/assets/images/oneks/light/create_k8s_cluster_2.png and b/assets/images/oneks/light/create_k8s_cluster_2.png differ diff --git a/assets/images/oneks/light/create_k8s_cluster_3.png b/assets/images/oneks/light/create_k8s_cluster_3.png index 41f77cf7a..b657a2f50 100644 Binary files a/assets/images/oneks/light/create_k8s_cluster_3.png and b/assets/images/oneks/light/create_k8s_cluster_3.png differ diff --git a/assets/images/oneks/light/create_k8s_cluster_4.png b/assets/images/oneks/light/create_k8s_cluster_4.png index d22329ea0..7284eb601 100644 Binary files a/assets/images/oneks/light/create_k8s_cluster_4.png and b/assets/images/oneks/light/create_k8s_cluster_4.png differ diff --git a/assets/images/oneks/light/create_k8s_cluster_flavours.png b/assets/images/oneks/light/create_k8s_cluster_flavours.png index 0ac4122ab..7943261ac 100644 Binary files a/assets/images/oneks/light/create_k8s_cluster_flavours.png and b/assets/images/oneks/light/create_k8s_cluster_flavours.png differ diff --git a/assets/images/oneks/light/create_k8s_cluster_version.png b/assets/images/oneks/light/create_k8s_cluster_version.png index ccf056e17..016beb509 100644 Binary files a/assets/images/oneks/light/create_k8s_cluster_version.png and b/assets/images/oneks/light/create_k8s_cluster_version.png differ diff --git a/assets/images/oneks/light/create_k8s_logs_running.png b/assets/images/oneks/light/create_k8s_logs_running.png index 1b11c701b..f9c2ce22a 100644 Binary files a/assets/images/oneks/light/create_k8s_logs_running.png and b/assets/images/oneks/light/create_k8s_logs_running.png differ diff --git a/assets/images/oneks/light/k8s_add_node_group.png b/assets/images/oneks/light/k8s_add_node_group.png index 16de53af3..a9800b4ed 100644 Binary files a/assets/images/oneks/light/k8s_add_node_group.png and b/assets/images/oneks/light/k8s_add_node_group.png differ diff --git a/assets/images/oneks/light/k8s_choose_flavours.png b/assets/images/oneks/light/k8s_choose_flavours.png index 33250e761..3fa7c3e7e 100644 Binary files a/assets/images/oneks/light/k8s_choose_flavours.png and b/assets/images/oneks/light/k8s_choose_flavours.png differ diff --git a/assets/images/oneks/light/k8s_kubeconfig.png b/assets/images/oneks/light/k8s_kubeconfig.png index 6e9cfbdc6..b4e2bcfd5 100644 Binary files a/assets/images/oneks/light/k8s_kubeconfig.png and b/assets/images/oneks/light/k8s_kubeconfig.png differ diff --git a/assets/images/oneks/light/k8s_logs_adding_node_group.png b/assets/images/oneks/light/k8s_logs_adding_node_group.png index 2d3c0e99f..c378bb2fe 100644 Binary files a/assets/images/oneks/light/k8s_logs_adding_node_group.png and b/assets/images/oneks/light/k8s_logs_adding_node_group.png differ diff --git a/assets/images/oneks/light/k8s_logs_creating.png b/assets/images/oneks/light/k8s_logs_creating.png index a3721f115..9ca6292df 100644 Binary files a/assets/images/oneks/light/k8s_logs_creating.png and b/assets/images/oneks/light/k8s_logs_creating.png differ diff --git a/assets/images/oneks/light/k8s_node_group_name.png b/assets/images/oneks/light/k8s_node_group_name.png index 69f10fc65..4741fae24 100644 Binary files a/assets/images/oneks/light/k8s_node_group_name.png and b/assets/images/oneks/light/k8s_node_group_name.png differ diff --git a/assets/images/oneks/light/k8s_recover_nodegroup_sunstone.png b/assets/images/oneks/light/k8s_recover_nodegroup_sunstone.png index e8d27e8e7..1d2d188f9 100644 Binary files a/assets/images/oneks/light/k8s_recover_nodegroup_sunstone.png and b/assets/images/oneks/light/k8s_recover_nodegroup_sunstone.png differ diff --git a/assets/images/oneks/light/k8s_upgrade_cluster_sunstone.png b/assets/images/oneks/light/k8s_upgrade_cluster_sunstone.png index 68c3afa50..e7d56139c 100644 Binary files a/assets/images/oneks/light/k8s_upgrade_cluster_sunstone.png and b/assets/images/oneks/light/k8s_upgrade_cluster_sunstone.png differ diff --git a/assets/images/oneks/light/k8s_user_inputs.png b/assets/images/oneks/light/k8s_user_inputs.png index 4dae23240..7d20a0ef1 100644 Binary files a/assets/images/oneks/light/k8s_user_inputs.png and b/assets/images/oneks/light/k8s_user_inputs.png differ diff --git a/content/platform_services/application_appliances/_index.md b/content/platform_services/application_appliances/_index.md new file mode 100644 index 000000000..75cc650db --- /dev/null +++ b/content/platform_services/application_appliances/_index.md @@ -0,0 +1,7 @@ +--- +title: "Marketplace Appliances" +description: "Pre-configured software solutions tailored for specific use cases." +weight: 2 +tags: +type: docs +--- diff --git a/content/solutions/integration_hub/application_appliances/community_marketplace.md b/content/platform_services/application_appliances/community_marketplace.md similarity index 87% rename from content/solutions/integration_hub/application_appliances/community_marketplace.md rename to content/platform_services/application_appliances/community_marketplace.md index 38b57de21..540e3a3d0 100644 --- a/content/solutions/integration_hub/application_appliances/community_marketplace.md +++ b/content/platform_services/application_appliances/community_marketplace.md @@ -6,6 +6,8 @@ categories: pageintoc: "68" tags: weight: "2" +toc_hide: true +headless: true --- diff --git a/content/platform_services/application_appliances/overview.md b/content/platform_services/application_appliances/overview.md new file mode 100644 index 000000000..ef87b8f0e --- /dev/null +++ b/content/platform_services/application_appliances/overview.md @@ -0,0 +1,17 @@ +--- +title: "Marketplace Appliances Overview" +linkTitle: "Overview" +weight: 1 +type: docs +--- + +OpenNebula Marketplace Appliances offer a streamlined way to launch specialized, pre-configured software solutions on your OpenNebula cloud deployment for specific use cases. This includes everything from basic Virtual Machines with specific operating systems through to advance cloud storage solutions and methods for deploying HPC or AI workloads. + +You can browse available Marketplace Appliances in the dedicated [OpenNebula Marketplace](https://marketplace.opennebula.io/) site. Below, you will find links to the documentation for several Marketplace Appliances that may be of interest for common use cases: + +* [**Harbor Container Registry**](https://github.com/OpenNebula/one-apps/wiki/harbor_intro): Deploy a secure, self managed image repository. +* [**MinIO**](https://github.com/OpenNebula/one-apps/wiki/minio_intro): Object storage solution with an AWS S3-compatible API. +* [**vLLM AI**](https://github.com/OpenNebula/one-apps/wiki/vllm_intro): Deploy high-performance LLM inferencing. +* [**Slurm**](https://github.com/OpenNebula/one-apps/wiki/slurm_intro): Fault-tolerant, highly scalable Cluster management and job scheduling system for HPC. +* [**NVIDIA NIM Service**](https://github.com/OpenNebula/one-apps/wiki/nim_intro): GPU-accelerated inference microservices for pre-trained and customized AI models. +* [**Rancher CAPI**](https://github.com/OpenNebula/one-apps/wiki/capi_intro): Out-of-the-box solution for managing Kubernetes Clusters using Rancher and OpenNebula. \ No newline at end of file diff --git a/content/platform_services/oneks/_index.md b/content/platform_services/oneks/_index.md index d4bc7acb9..3a173b33c 100644 --- a/content/platform_services/oneks/_index.md +++ b/content/platform_services/oneks/_index.md @@ -1,6 +1,6 @@ --- title: "OneKS: Elastic Kubernetes as a Service on OpenNebula (EE)" -linkTitle: "OneKS - Elastic Kubernetes (EE)" +linkTitle: "Elastic Kubernetes (EE)" date: "2026-05-12" description: "OneKS provides Elastic Kubernetes as a Service on OpenNebula. It offers a structured way to create, access, operate, upgrade, recover, and deprovision Kubernetes Clusters." categories: diff --git a/content/platform_services/oneks/getting_started/basic_configuration.md b/content/platform_services/oneks/getting_started/basic_configuration.md index 9fc0ce707..58bfd8c6d 100644 --- a/content/platform_services/oneks/getting_started/basic_configuration.md +++ b/content/platform_services/oneks/getting_started/basic_configuration.md @@ -9,7 +9,7 @@ weight: "2" type: docs --- -Before creating a Cluster, ensure that the minimum required components are configured and available. +Before creating a K8s Cluster, ensure that the minimum required components are configured and available. ## OneKS Service @@ -23,7 +23,7 @@ The service should be in the active (`running`) state. ## OneGate Service -Verify that OneGate is configured and reachable. OneGate is required during Cluster provisioning because the bootstrap process uses it to communicate with OpenNebula services. +Verify that OneGate is configured and reachable. OneGate is required during K8s Cluster provisioning because the bootstrap process uses it to communicate with OpenNebula services. Check the OneGate service status on the Front-end command line: @@ -35,7 +35,7 @@ Validate the OneGate configuration using the OpenNebula OneGate [documentation]( ## Transparent Proxy Configuration -Verify that the [transparent proxy]({{% relref "product/virtual_machines_operation/virtual_machines_networking/tproxy/" %}}) is configured to expose OneGate and the OpenNebula XML-RPC API through the public network gateway. +Verify that the [transparent proxy]({{% relref "product/virtual_machines_operation/virtual_machines_networking/tproxy/" %}}) is configured to expose OneGate and the OpenNebula XML-RPC API through the Front-end public network. The configuration is typically defined in the following location on the OpenNebula Front-end: @@ -47,19 +47,19 @@ Example configuration: ```default :tproxy: - - :remote_addr: 192.168.150.1 # Public network gateway IP + - :remote_addr: 192.168.150.1 # Front-end public network IP :remote_port: 5030 :service_port: 5030 - - :remote_addr: 192.168.150.1 # Public network gateway IP + - :remote_addr: 192.168.150.1 # Front-end public network IP :remote_port: 2633 :service_port: 2633 ``` -Replace `192.168.150.1` with the gateway IP address of the public Virtual Network. +Replace `192.168.150.1` with the Front-end IP address of the public Virtual Network and save the file. On Front-end command line, as the oneadmin system user, sync the OpenNebulaNetwork.conf file with the hypervisor Hosts, by running `onehost sync -f`. ## Public and Private Virtual Networks -Identify the OpenNebula Virtual Network IDs that will be used by the Cluster. On the Front-end command line, run the following command to inspect the available networks: +Identify the OpenNebula Virtual Network IDs that will be used by the K8s Cluster. On the Front-end command line, run the following command to inspect the available networks: ```shell onevnet list @@ -67,13 +67,85 @@ onevnet list You need: -* A **public Virtual Network**, used as the gateway to the Internet and for external Cluster connectivity. -* A **private Virtual Network**, used for internal communication between Cluster nodes. +* A **public Virtual Network**, used as the gateway to the Internet and for external K8s Cluster connectivity. +* A **private Virtual Network**, used for internal communication between K8s Cluster nodes. ## User Permissions -Verify that the user has permission to create and manage OneKS Clusters and the related OpenNebula resources, including virtual machines, Virtual Networks, images, and templates. +Verify that the user has permission to create and manage OneKS K8s Clusters and the related OpenNebula resources, including Virtual Machines, Virtual Networks, images, and templates. -## Kubectl Client +## kubectl Client -To validate or manage the created Clusters from the Host, instead of accessing the Cluster VMs directly, [kubectl](https://kubernetes.io/docs/tasks/tools/) must be installed on the Host where the retrieved kubeconfig will be used. \ No newline at end of file +[kubectl](https://kubernetes.io/docs/reference/kubectl/) is the official command-line interface for Kubernetes. kubectl communicates with K8s Clusters launched by OneKS remotely from the Front-end Host, removing the need to interact directly with the K8s Cluster VMs themselves. kubectl handles the following key functions: + +* **K8s Cluster Management**: View nodes, health status, and resource usage. +* **Workload Deployment**: Create, update, and delete pods, services and containerized application deployments. +* **Troubleshooting**: Retrieving logs, describing pod and node statuses or errors. +* **Configuration**: Manage secrets, environment variables and storage. + +kubectl must be installed on the Front-end Host machine. On a Linux machine, run the following command to install kubectl: + +1. Download the latest release with the following command: + +{{< tabpane text=true right=false >}} +{{% tab header="**Architecture**:" disabled=true /%}} + +{{% tab header="x86-64"%}} +```shell +curl -fsSL "https://dl.k8s.io/release/$(curl -L -s \ +https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl" +``` +{{% /tab %}} + +{{% tab header="ARM64"%}} +```shell +curl -LO "https://dl.k8s.io/release/$(curl -L -s \ +https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl" +``` +{{% /tab %}} +{{< /tabpane >}} + +To download a specific version of kubectl, replace `$(curl -L -s https://dl.k8s.io/release/stable.txt)` in the above commands with the version number. E.g. for version 1.36.0: +{{< tabpane text=true right=false >}} +{{% tab header="**Architecture**:" /%}} + +{{% tab header="x86-64"%}} +```shell +curl -fsSL "https://dl.k8s.io/release/v1.36.0/bin/linux/amd64/kubectl" +``` +{{% /tab %}} + +{{% tab header="ARM64"%}} +```shell +curl -LO "https://dl.k8s.io/release/v1.36.0/bin/linux/arm64/kubectl" +``` +{{% /tab %}} +{{< /tabpane >}} + +2. Install kubectl: + +```shell +sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl +``` + +{{< alert title="Note" type="primary" >}} +If you do not have root access on the target system, you can still install kubectl to the `~/.local/bin` directory: +```shell +chmod +x kubectl +mkdir -p ~/.local/bin +mv ./kubectl ~/.local/bin/kubectl +# and then append (or prepend) ~/.local/bin to $PATH +``` +{{< /alert >}} + +3. Ensure the version you have installed is up-to-date or the expected version: + +```shell +kubectl version --client +``` + +If the above command is not suitable for your Front-end Host configuration, consult the [kubectl installation documentation](https://kubernetes.io/docs/tasks/tools/) for [MacOS](https://kubernetes.io/docs/tasks/tools/install-kubectl-macos/) or [Windows](https://kubernetes.io/docs/tasks/tools/install-kubectl-windows/). + +## Next Steps + +After completing the basic configuration steps described here, you are ready to start provisioning K8s Clusters with OneKS. Move on to the [OneKS Quick-start Guide]({{% relref "platform_services/oneks/getting_started/quick_start/" %}}) to learn how to deploy a basic K8s Cluster. \ No newline at end of file diff --git a/content/platform_services/oneks/getting_started/core_concepts.md b/content/platform_services/oneks/getting_started/core_concepts.md index e61c73bcf..3537ae28c 100644 --- a/content/platform_services/oneks/getting_started/core_concepts.md +++ b/content/platform_services/oneks/getting_started/core_concepts.md @@ -13,9 +13,9 @@ This section explains the main OneKS concepts used throughout the documentation. Users mainly interact with: -* **Cluster Profiles**: Reusable blueprints for Cluster component configuration. -* **Clusters**: Top-level resources representing deployed Kubernetes Clusters. -* **Node Groups**: Scalable worker-capacity groups attached to Clusters. +* **K8s Cluster Profiles**: Reusable blueprints for K8s Cluster component configuration. +* **K8s Clusters**: Top-level resources representing deployed K8s Clusters. +* **Node Groups**: Scalable worker-capacity groups attached to K8s Clusters. * **Topologies**: Deployment layouts that combine control planes, node groups, networks, and runtime dependencies. Lower-level resources such as OpenNebula VM templates, images, Virtual Networks, virtual routers, seed VMs, and Cluster API objects are managed underneath these abstractions. @@ -26,9 +26,9 @@ The seed VM is a managed, temporary OpenNebula VM dependency used during control It is not a first-class user resource, and users do not create or manage it directly. -During control-plane provisioning, OneKS creates the seed VM from an existing OpenNebula VM template. OneKS injects the rendered control-plane and Cluster API specification into the VM context, attaches the seed VM to the Cluster public network, and monitors its bootstrap state. +During control-plane provisioning, OneKS creates the seed VM from an existing OpenNebula VM template. OneKS injects the rendered control-plane and Cluster API specification into the VM context, attaches the seed VM to the K8s Cluster public network, and monitors its bootstrap state. -The seed VM performs the bootstrap and Cluster API pivoting workflow. It starts a temporary management environment, applies the Cluster API and RKE2 resources, waits for the workload control plane, retrieves the workload kubeconfig, initializes the providers in the workload Cluster, and moves the Cluster API objects. +The seed VM performs the bootstrap and Cluster API pivoting workflow. It starts a temporary management environment, applies the Cluster API and RKE2 resources, waits for the workload control plane, retrieves the workload kubeconfig, initializes the providers in the workload K8s Cluster, and moves the Cluster API objects. OneKS monitors the seed VM through its `ONEKS_STATE` value. @@ -37,24 +37,24 @@ OneKS monitors the seed VM through its `ONEKS_STATE` value. The seed VM is a critical part of the control-plane creation process, but it remains an implementation detail hidden from normal user workflows. -## Cluster Profiles +## K8s Cluster Profiles -A Cluster Profile is a reusable blueprint used to define the configuration of a OneKS Cluster component. +A K8s Cluster Profile is a reusable blueprint used to define the configuration of a OneKS K8s Cluster component. -In OneKS, profiles are used to define both control-plane configuration and node-group configuration. Profiles allow users to standardize how Kubernetes Clusters are created. Instead of requiring users to provide every low-level infrastructure detail, OneKS exposes predefined families, flavours, defaults, and validated inputs. +In OneKS, profiles are used to define both control-plane configuration and node-group configuration. Profiles allow users to standardize how K8s Clusters are created. Instead of requiring users to provide every low-level infrastructure detail, OneKS exposes predefined families, flavours, defaults, and validated inputs. -A Cluster profile can define: +A K8s Cluster profile can define: * **Supported Kubernetes Versions**: The Kubernetes versions that can be deployed with the profile. * **Families and Flavours**: The selectable configuration groups and variants exposed to users. * **Default Capacity Values**: Default compute, memory, disk, and instance-count values. -* **User Inputs**: Fields collected during Cluster or node-group creation. +* **User Inputs**: Fields collected during K8s Cluster or node-group creation. * **Validation Rules**: Constraints applied to user-provided values. * **Override Behavior**: Whether user-provided values can override flavour defaults. -* **Runtime Dependencies**: Dependencies such as a temporary seed VM or a Cluster router. +* **Runtime Dependencies**: Dependencies such as a temporary seed VM or a K8s Cluster router. * **Templates**: Definitions used to render the underlying OpenNebula and Cluster API resources. -Profiles are the main mechanism for making OneKS Cluster deployments repeatable, controlled, and consistent across users and environments. +Profiles are the main mechanism for making OneKS K8s Cluster deployments repeatable, controlled, and consistent across users and environments. ## Families and Flavours @@ -68,13 +68,13 @@ For example, a default OneKS deployment may expose: * **Control-plane Family** `general`: Includes flavours such as `standalone` and `ha`. * **Node-group Family** `general`: Includes flavours such as `small`, `medium`, and `large`. -When users create a Cluster or node group, they select a family and a flavour. OneKS then applies the defaults, validation rules, and dependencies associated with that selection. +When users create a K8s Cluster or node group, they select a family and a flavour. OneKS then applies the defaults, validation rules, and dependencies associated with that selection. This allows users to expose simple choices to users while keeping the underlying infrastructure configuration controlled. ## User Inputs and Defaults -Profiles may define user inputs. These inputs are collected during Cluster or node-group creation and are combined with the defaults defined by the selected flavour. +Profiles may define user inputs. These inputs are collected during K8s Cluster or node-group creation and are combined with the defaults defined by the selected flavour. Common inputs include: @@ -95,7 +95,7 @@ This lets users decide whether a flavour is fixed or user-customizable. ## Default Profiles -A OneKS deployment may expose default profiles for common Cluster patterns. The exact profiles available depend on the user configuration. A typical default configuration includes the following profiles. +A OneKS deployment may expose default profiles for common K8s Cluster patterns. The exact profiles available depend on the user configuration. A typical default configuration includes the following profiles. **Control-plane profile:** @@ -124,7 +124,7 @@ Each flavour can define default values for CPU, virtual CPU, memory, disk size, ## Custom Profiles -Custom profiles are an user extension mechanism. Users can define new profiles to expose additional Cluster offerings or adapt OneKS to a specific infrastructure environment. +Custom profiles are an user extension mechanism. Users can define new profiles to expose additional K8s Cluster offerings or adapt OneKS to a specific infrastructure environment. A typical custom profile workflow includes: @@ -134,62 +134,62 @@ A typical custom profile workflow includes: * **Default Values**: Define default values for each flavour. * **User Inputs**: Define the inputs users can provide. * **Validation Rules**: Define constraints for the accepted inputs. -* **Dependencies**: Define required dependencies such as a seed VM or Cluster router. +* **Dependencies**: Define required dependencies such as a seed VM or K8s Cluster router. * **Testing**: Validate the profile before making it available to users. -Custom profiles are mainly relevant for users who manage the OneKS service and define the Cluster options exposed to users. +Custom profiles are mainly relevant for users who manage the OneKS service and define the K8s Cluster options exposed to users. -## Clusters +## K8s Clusters -A OneKS Cluster is the top-level resource exposed to users and users. It represents a deployed Kubernetes Cluster running on OpenNebula. +A OneKS K8s Cluster is the top-level resource exposed to users and users. It represents a deployed K8s Cluster running on OpenNebula. -A Cluster includes: +A K8s Cluster includes: -* **Cluster Identity and Metadata**: The name, description, ownership, and registration information for the Cluster. -* **Kubernetes Version**: The Kubernetes version deployed in the Cluster. -* **Network References**: The public and private OpenNebula Virtual Networks used by the Cluster. +* **K8s Cluster Identity and Metadata**: The name, description, ownership, and registration information for the K8s Cluster. +* **Kubernetes Version**: The Kubernetes version deployed in the K8s Cluster. +* **Network References**: The public and private OpenNebula Virtual Networks used by the K8s Cluster. * **Control Plane**: One logical control-plane group. * **Node Groups**: Zero or more worker-capacity groups. -* **Lifecycle State**: The current operational state of the Cluster. +* **Lifecycle State**: The current operational state of the K8s Cluster. * **Historical Events**: Recorded lifecycle actions and state changes. * **Kubeconfig Retrieval**: Access information for the Kubernetes API server. -* **Logs**: Cluster lifecycle logs and operational visibility. +* **Logs**: K8s Cluster lifecycle logs and operational visibility. -The OneKS API, CLI, and Sunstone workflows are centered around Cluster resources. +The OneKS API, CLI, and Sunstone workflows are centered around K8s Cluster resources. -Each OneKS Cluster has one logical control-plane group. Depending on the selected control-plane flavour, this group may contain: +Each OneKS K8s Cluster has one logical control-plane group. Depending on the selected control-plane flavour, this group may contain: * **Standalone Control Plane**: One control-plane node. * **High-availability Control Plane**: Multiple control-plane nodes. -Even in `HA` deployments, the control plane is represented as one logical control-plane group. Users do not manually create separate control-plane groups. Control-plane capacity and topology are determined during Cluster creation by the selected profile family and flavour. +Even in `HA` deployments, the control plane is represented as one logical control-plane group. Users do not manually create separate control-plane groups. Control-plane capacity and topology are determined during K8s Cluster creation by the selected profile family and flavour. -A Cluster requires two OpenNebula Virtual Networks: +A K8s Cluster requires two OpenNebula Virtual Networks: * **Public Virtual Network**: Provides external connectivity where required and supports required bootstrap and service access paths. -* **Private Virtual Network**: Provides internal Cluster communication and helps preserve network isolation between Cluster nodes. +* **Private Virtual Network**: Provides internal K8s Cluster communication and helps preserve network isolation between K8s Cluster nodes. -The user or user must provide the public and private network IDs during Cluster creation. +The user or user must provide the public and private network IDs during K8s Cluster creation. -A OneKS Cluster coordinates several lower-level infrastructure resources, including: +A OneKS K8s Cluster coordinates several lower-level infrastructure resources, including: * **OpenNebula VMs**: Virtual Machines used for control-plane and worker nodes. -* **VM Templates**: OpenNebula templates used to instantiate Cluster-related VMs. -* **Images**: Base images used by templates and Cluster nodes. -* **Virtual Networks**: Public and private networks selected during Cluster creation. -* **Virtual Routers**: Routing components used by the Cluster networking topology. +* **VM Templates**: OpenNebula templates used to instantiate K8s Cluster-related VMs. +* **Images**: Base images used by templates and K8s Cluster nodes. +* **Virtual Networks**: Public and private networks selected during K8s Cluster creation. +* **Virtual Routers**: Routing components used by the K8s Cluster networking topology. * **Seed VMs**: Temporary bootstrap VMs used during control-plane provisioning. -* **Cluster API and CAPONE resources**: Lower-level lifecycle resources used to provision the Kubernetes Cluster. +* **Cluster API and CAPONE resources**: Lower-level lifecycle resources used to provision the K8s Cluster. -Users normally do not interact with these resources directly during standard workflows. OneKS orchestrates them as part of the Cluster lifecycle. +Users normally do not interact with these resources directly during standard workflows. OneKS orchestrates them as part of the K8s Cluster lifecycle. -A Cluster has a lifecycle state that reflects its current operational condition. Common lifecycle states include `PROVISIONING`, `RUNNING`, `WARNING`, and failure states. +A K8s Cluster has a lifecycle state that reflects its current operational condition. Common lifecycle states include `PROVISIONING`, `RUNNING`, `WARNING`, and failure states. -A Cluster is considered ready for Kubernetes use when it reaches the `RUNNING` state and the Kubernetes nodes report `Ready` through `kubectl`. +A K8s Cluster is considered ready for Kubernetes use when it reaches the `RUNNING` state and the Kubernetes nodes report `Ready` through `kubectl`. The full state list and reconciliation behavior are documented in [Monitoring and Troubleshooting]({{% relref "platform_services/oneks/management/monitoring_and_troubleshooting/" %}}). -After a Cluster is running, users access it by retrieving its `kubeconfig`, which contains the Kubernetes API endpoint and credentials required to connect to the Cluster. +After a K8s Cluster is running, users access it by retrieving its `kubeconfig`, which contains the Kubernetes API endpoint and credentials required to connect to the K8s Cluster. Example: @@ -207,11 +207,11 @@ The expected result is that the control-plane nodes and any worker nodes appear ## Node Groups -A Node Group is a scalable worker-capacity group attached to a OneKS Cluster. Node groups are the main operational unit for managing worker capacity in OneKS. +A Node Group is a scalable worker-capacity group attached to a OneKS K8s Cluster. Node groups are the main operational unit for managing worker capacity in OneKS. A node group defines: -* **Parent Cluster**: The Cluster the node group belongs to. +* **Parent K8s Cluster**: The K8s Cluster the node group belongs to. * **Profile Family**: The node-group family selected during creation. * **Flavour**: The worker node size or capacity profile. * **Input Values**: Node count and resource sizing values. @@ -220,7 +220,7 @@ A node group defines: * **Dependency State**: The state of any runtime dependencies. * **Historical Events**: Recorded lifecycle actions and state changes. -Users create node groups after the Cluster control plane is running. +Users create node groups after the K8s Cluster control plane is running. Worker nodes host application workloads. When a node group is created, OneKS provisions the requested number of worker nodes using the selected node-group flavour. @@ -230,11 +230,11 @@ Example worker flavours: * `medium`: balanced workloads. * `large`: resource-intensive workloads. -A node group is always attached to an existing Cluster. +A node group is always attached to an existing K8s Cluster. Conceptually, creating a node group requires: -* **Parent Cluster ID**: The ID of the Cluster that will receive the node group. +* **Parent K8s Cluster ID**: The ID of the K8s Cluster that will receive the node group. * **Node-group Name**: The name used to identify the worker capacity group. * **Node-group Family**: The profile family used for the node group. * **Node-group Flavour**: The selected worker capacity profile. @@ -242,9 +242,9 @@ Conceptually, creating a node group requires: In an interactive CLI or Web UI flow, the user selects these values step by step. -After the node group is created, OneKS provisions the worker VMs and joins them to the Kubernetes Cluster. +After the node group is created, OneKS provisions the worker VMs and joins them to the K8s Cluster. -Scaling changes the number of worker nodes in a node group. Scaling is performed against node groups, not directly against the Cluster control plane. +Scaling changes the number of worker nodes in a node group. Scaling is performed against node groups, not directly against the K8s Cluster control plane. For example, scaling a node group to three nodes means that OneKS reconciles that node group until it contains three worker nodes. @@ -260,14 +260,14 @@ A node group is ready for Kubernetes workloads when it reaches the `RUNNING` sta The full state list and reconciliation behavior are documented in **Monitoring and Troubleshooting**. -A Cluster can have: +A K8s Cluster can have: -* **One Control-plane Group**: The logical control-plane group created during Cluster provisioning. -* **Zero Node Groups**: A control-plane-only Cluster. -* **One Node Group**: A simple Cluster with one worker capacity group. -* **Multiple Node Groups**: A Cluster with separate worker pools for different workload types or capacity profiles. +* **One Control-plane Group**: The logical control-plane group created during K8s Cluster provisioning. +* **Zero Node Groups**: A control-plane-only K8s Cluster. +* **One Node Group**: A simple K8s Cluster with one worker capacity group. +* **Multiple Node Groups**: A K8s Cluster with separate worker pools for different workload types or capacity profiles. -For example, a Cluster could have: +For example, a K8s Cluster could have: * **Small Node Group**: Lightweight services * **Medium Node Group**: General workloads @@ -277,16 +277,16 @@ The exact options depend on the profiles configured by the user. ## Topologies -A topology describes how a OneKS Cluster is assembled from its control plane, node groups, networks, and runtime dependencies. +A topology describes how a OneKS K8s Cluster is assembled from its control plane, node groups, networks, and runtime dependencies. A OneKS topology is determined by: * **Control-plane Profile and flavour**: The selected configuration for the Kubernetes control plane. -* **Kubernetes Version**: The Kubernetes version deployed in the Cluster. -* **Public and Private Networks**: The OpenNebula networks selected during Cluster creation. +* **Kubernetes Version**: The Kubernetes version deployed in the K8s Cluster. +* **Public and Private Networks**: The OpenNebula networks selected during K8s Cluster creation. * **Control-plane Node Count**: The number of control-plane nodes defined by the selected flavour. * **Node-group Configuration**: The number and size of worker node groups. -* **Runtime Dependencies**: Supporting components such as the seed VM and Cluster router. +* **Runtime Dependencies**: Supporting components such as the seed VM and K8s Cluster router. Topologies allow OneKS to expose different Kubernetes deployment models without requiring users to manually construct the underlying infrastructure. @@ -294,25 +294,25 @@ A standalone topology uses a single control-plane node. This topology is suitable for: -* **Development Environments**: Clusters used for development and experimentation. -* **Test Environments**: Clusters used for validation and temporary testing. -* **Evaluation Clusters**: Clusters used to assess OneKS or Kubernetes behavior. +* **Development Environments**: K8s Clusters used for development and experimentation. +* **Test Environments**: K8s Clusters used for validation and temporary testing. +* **Evaluation K8s Clusters**: K8s Clusters used to assess OneKS or Kubernetes behavior. * **Non-critical Workloads**: Workloads that do not require control-plane redundancy. A standalone control plane is simpler and consumes fewer resources, but it does not provide control-plane redundancy. If the single control-plane node fails, the Kubernetes API may become unavailable until the node or underlying infrastructure is recovered. A high-availability (`HA`) control-plane topology uses multiple control-plane nodes. This topology is intended for environments where control-plane availability is more important. -In OneKS, an `HA` control plane is represented as multiple control-plane nodes inside one logical control-plane group. Users select the `HA` flavour during Cluster creation. OneKS then orchestrates the underlying infrastructure and control-plane layout. +In OneKS, an `HA` control plane is represented as multiple control-plane nodes inside one logical control-plane group. Users select the `HA` flavour during K8s Cluster creation. OneKS then orchestrates the underlying infrastructure and control-plane layout. -Worker capacity is provided by node groups. A Cluster may start with no worker node groups, or users may add one or more node groups after the control plane is running. +Worker capacity is provided by node groups. A K8s Cluster may start with no worker node groups, or users may add one or more node groups after the control plane is running. Each node group can have its own flavour and count. Example standalone topology: ```default -Cluster +K8s Cluster ├── Control plane: standalone └── Node groups └── small-workers, count: 2 @@ -321,7 +321,7 @@ Cluster Example HA topology: ```default -Cluster +K8s Cluster ├── Control plane: ha └── Node groups ├── medium-workers, count: 3 @@ -330,26 +330,26 @@ Cluster This model allows users to scale worker capacity independently from the control plane. -OneKS Cluster networking uses the public and private OpenNebula Virtual Networks selected during Cluster creation. +OneKS K8s Cluster networking uses the public and private OpenNebula Virtual Networks selected during K8s Cluster creation. * **Public Network**: Provides external connectivity and supports required bootstrap and service access paths. -* **Private Network**: Provides internal communication between Cluster nodes. -* **Virtual Router**: Connects the OpenNebula networking layer with the Kubernetes Cluster topology where required. +* **Private Network**: Provides internal communication between K8s Cluster nodes. +* **Virtual Router**: Connects the OpenNebula networking layer with the K8s Cluster topology where required. Some topologies require runtime dependencies. Common dependencies include: * **Seed VM**: Temporary VM used during control-plane bootstrap. -* **Cluster router**: Router-related dependency used to support Cluster connectivity. +* **K8s Cluster router**: Router-related dependency used to support K8s Cluster connectivity. * **OneGate**: OpenNebula service used by VMs to communicate with OpenNebula during bootstrap and runtime configuration. -* **Transparent proxy, `tproxy`**: Networking configuration used to expose required OpenNebula services such as OneGate and the XML-RPC API through the public network gateway. +* **Transparent proxy** `tproxy`: Networking configuration used to expose required OpenNebula services such as OneGate and the XML-RPC API through the Front-end public network. These dependencies are normally configured by the user and consumed automatically by OneKS during lifecycle operations. Users do not build the topology manually. Instead, they select: * **Kubernetes Version**: The version to deploy. -* **Public Network**: The OpenNebula public Virtual Network used by the Cluster. -* **Private Network**: The OpenNebula private Virtual Network used by the Cluster. +* **Public Network**: The OpenNebula public Virtual Network used by the K8s Cluster. +* **Private Network**: The OpenNebula private Virtual Network used by the K8s Cluster. * **Control-plane Flavour**: The selected control-plane deployment model. * **Node-group Flavour and Count**: The worker capacity profile and number of workers, if additional capacity is required. diff --git a/content/platform_services/oneks/getting_started/overview.md b/content/platform_services/oneks/getting_started/overview.md index 30e72b200..04d0f334d 100644 --- a/content/platform_services/oneks/getting_started/overview.md +++ b/content/platform_services/oneks/getting_started/overview.md @@ -9,59 +9,66 @@ weight: "1" type: docs --- -OneKS provides Elastic Kubernetes as a Service on OpenNebula. It offers a structured way to create, access, operate, upgrade, recover, and deprovision Kubernetes Clusters by combining a user-facing service layer with Cluster API-based infrastructure provisioning through CAPONE, the Cluster API provider for OpenNebula. +OneKS provides Elastic Kubernetes as a Service on OpenNebula. It offers a structured way to create, access, operate, upgrade, recover, and deprovision Kubernetes Clusters (K8s Clusters) by combining a user-facing service layer with Cluster API-based infrastructure provisioning through CAPONE, the Cluster API provider for OpenNebula. OneKS is designed for teams that need a simple and repeatable way to consume Kubernetes inside OpenNebula. Typical use cases include development and test environments, self-service Kubernetes delivery in private cloud environments, and standardized Cluster offerings for different sizes and topologies. -OneKS builds on CAPONE to expose a Cluster-centric lifecycle model for users and users. Users interact mainly with OneKS Clusters and node groups, while lower-level OpenNebula, Cluster API, and dependency-management details are handled underneath. +OneKS builds on CAPONE to expose a K8s Cluster-centric lifecycle model for users and users. Users interact mainly with OneKS K8s Clusters and node groups, while lower-level OpenNebula, Cluster API, and dependency-management details are handled underneath. + +## How Should I Read this Chapter + +If you have not used OneKS before, you should start by reading the [Basic Configuration Guide]({{% relref "platform_services/oneks/getting_started/basic_configuration/" %}}) to set up OneKS then follow the [Quick-start Guide]({{% relref "platform_services/oneks/getting_started/quick_start/" %}}) where you will learn to set up a basic K8s Cluster with OneKS. After completing the Quick-start Guide, move on to [Core Concepts]({{% relref "platform_services/oneks/getting_started/core_concepts/" %}}) to familiarize yourself with key OneKS concepts. + +After completing the introductory documentation, you can find more information about managing K8s Clusters with OneKS in the following reference documentation: +* [K8s Cluster Lifecycle Management]({{% relref "platform_services/oneks/management/k8s_cluster_lifecycle_management/" %}}) +* [Monitoring and Troubleshooting]({{% relref "platform_services/oneks/management/monitoring_and_troubleshooting/" %}}) +* [Configuration]({{% relref "platform_services/oneks/management/configuration/" %}}) +* [OneKS REST API]({{% relref "platform_services/oneks/references/oneks_api/" %}}) +* [OneKS CLI]({{% relref "platform_services/oneks/references/oneks_cli/" %}}) + +{{< alert title="Note" type="primary" >}} +It is important while reading this documentation to differentiate the concepts of **OpenNebula Clusters** and **Kubernetes (K8s) Clusters**: +* **OpenNebula Clusters**: Logical groupings of OpenNebula resources (Hosts, datastores and Virtual Networks) that provide compute capacity for cloud workloads. +* **K8s Clusters**: Collections of node instances (VMs) managed by a K8s control plane to automate the deployment, scaling and management of containerized applications. + +K8s Clusters provisioned by OneKS run as a guest workload on top of OpenNebula resources and should be considered as distinct entities to OpenNebula Clusters. It is possible, for example, to deploy *multiple* independent K8s Clusters within a *single* OpenNebula Cluster. +{{< /alert >}} ## Interfaces OneKS can be accessed through the following interfaces: -* **OneKS CLI**: Used for manual Cluster and node-group operations from the command line. +* **OneKS CLI**: Used for manual K8s Cluster and node-group operations from the command line. * **OneKS REST API**: Exposed under `/api/v1` for automation and programmatic integration. -* **Sunstone Web UI**: Provides graphical workflows for creating, accessing, and managing OneKS Clusters. +* **Sunstone Web UI**: Provides graphical workflows for creating, accessing, and managing OneKS K8s Clusters. ## What OneKS Manages -OneKS manages Kubernetes Clusters as top-level resources. A Cluster owns or coordinates: +OneKS manages K8s Clusters as top-level resources. A K8s Cluster owns or coordinates: * **Control Plane**: One logical control-plane group, containing one or more control-plane nodes depending on the selected control-plane flavour. -* **Node Groups**: Zero or more worker-capacity groups attached to the Cluster. +* **Node Groups**: Zero or more worker-capacity groups attached to the K8s Cluster. * **Supporting Infrastructure**: Networks, images, VM templates, temporary seed VMs, virtual routers, and related OpenNebula resources. -* **Lifecycle State**: The current operational state of the Cluster and its groups. +* **Lifecycle State**: The current operational state of the K8s Cluster and its groups. * **Historical Events**: Lifecycle actions and state transitions. * **Access Information**: kubeconfig retrieval for Kubernetes API access. -* **Logs:** Cluster-level and group-level lifecycle logs. +* **Logs:** K8s Cluster-level and group-level lifecycle logs. -OneKS users interact primarily with the Cluster and node-group domains. Lower-level OpenNebula, CAPONE, and Cluster API resources are orchestrated beneath those abstractions. +OneKS users interact primarily with the K8s Cluster and node-group domains. Lower-level OpenNebula, CAPONE, and Cluster API resources are orchestrated beneath those abstractions. ## Related Components OneKS should be understood together with the following adjacent components: * [**CAPONE**]({{% relref "product/integration_references/kubernetes/kubernetes_cluster_api/" %}}): The Cluster API provider for OpenNebula. It provides the lower-level declarative lifecycle integration between Kubernetes Cluster API and OpenNebula infrastructure. -* [**OpenNebula Cloud Resources**]({{% relref "product/virtual_machines_operation/" %}}): VM templates, networks, images, virtual routers, and related infrastructure resources used to provision and operate the Cluster. +* [**OpenNebula Cloud Resources**]({{% relref "product/virtual_machines_operation/" %}}): VM templates, networks, images, virtual routers, and related infrastructure resources used to provision and operate the K8s Cluster. * [**RKE2**](https://docs.rke2.io/): The Kubernetes distribution used by the current OneKS implementation. -* [**OneKS API**]({{% relref "platform_services/oneks/references/oneks_api/" %}}): The programmatic interface for Cluster and node-group lifecycle operations. +* [**OneKS API**]({{% relref "platform_services/oneks/references/oneks_api/" %}}): The programmatic interface for K8s Cluster and node-group lifecycle operations. * [**Kubernetes Cloud Provider**]({{% relref "product/integration_references/kubernetes/kubernetes_cloud_provider/" %}}): The in-cluster integration layer for OpenNebula infrastructure behavior. -* [**OneGate**]({{% relref "product/operation_references/opennebula_services_configuration/onegate/" %}}): The OpenNebula service used by Virtual Machines to communicate with OpenNebula during bootstrap and runtime configuration. In a OneKS deployment, OneGate must be configured and reachable so the Cluster bootstrap process can complete successfully. -* [**Transparent Proxy**]({{% relref "product/virtual_machines_operation/virtual_machines_networking/tproxy/" %}}) `tproxy`: The OpenNebula networking configuration used to expose required OpenNebula services, such as OneGate and the XML-RPC API, through the public network gateway. OneKS deployments require tproxy rules for ports **5030** and **2633**. +* [**OneGate**]({{% relref "product/operation_references/opennebula_services_configuration/onegate/" %}}): The OpenNebula service used by Virtual Machines to communicate with OpenNebula during bootstrap and runtime configuration. In a OneKS deployment, OneGate must be configured and reachable so the K8s Cluster bootstrap process can complete successfully. +* [**Transparent Proxy**]({{% relref "product/virtual_machines_operation/virtual_machines_networking/tproxy/" %}}) `tproxy`: The OpenNebula networking configuration used to expose required OpenNebula services, such as OneGate and the XML-RPC API, through the Front-end public network OneKS deployments require tproxy rules for ports **5030** and **2633**. * [**Cluster API References**]({{% relref "product/integration_references/kubernetes/kubernetes_cluster_api/" %}}): Useful when understanding the lower-level declarative lifecycle and CAPONE integration details. -### Supported Versions - -OneKS supports the Kubernetes versions exposed by the configured Cluster profiles. - -In the default profiles described in this document, the supported Kubernetes versions are: **v1.31.4** and **v1.32.9**. This section provides a first-use workflow for deploying a OneKS Cluster. This quick start guide uses the Sunstone Web UI. CLI and API workflows are covered in [Cluster Lifecycle Management]({{% relref "k8s_cluster_lifecycle_management" %}}). - -Quick Start workflow: +## Supported Versions -* **Prepare the Environment**: Verify the minimum OneKS, OneGate, networking, profile, and permission requirements. -* **Create the Cluster**: Use the Sunstone Web UI Cluster creation wizard. -* **Wait for the Cluster**: Wait until the Cluster reaches the `RUNNING` state. -* **Retrieve kubeconfig**: Copy the kubeconfig from the Cluster detail view. -* **Validate Kubernetes Access**: Run `kubectl get nodes` using the retrieved kubeconfig. -* **Add Worker Capacity**: Create a node group if worker nodes are required. -* **Validate Workload Deployment**: Deploy a simple NGINX workload and test in-cluster service connectivity. \ No newline at end of file +OneKS supports the K8s versions exposed by the configured K8s Cluster profiles. Refer to the [Platform Notes]({{% relref "software/release_information/release_notes/platform_notes/#kubernetes" %}}) to see the Kubernetes versions currently supported bye OneKS. \ No newline at end of file diff --git a/content/platform_services/oneks/getting_started/quick_start.md b/content/platform_services/oneks/getting_started/quick_start.md index 2cbda4eac..ebc1a21c6 100644 --- a/content/platform_services/oneks/getting_started/quick_start.md +++ b/content/platform_services/oneks/getting_started/quick_start.md @@ -1,5 +1,5 @@ --- -title: "Quick Start" +title: "OneKS Quick Start" linkTitle: "Quick Start" date: "2026-05-12" description: @@ -9,83 +9,156 @@ weight: "3" type: docs --- -This section provides a short first-use workflow for deploying a OneKS Cluster. From the left-hand navigation menu in Sunstone, go to **Kubernetes -> K8S Clusters**: +This quick-start guide uses the Sunstone Web UI to demonstrate a short first-use workflow for deploying a simple K8s Cluster with OneKS. CLI and API workflows are covered in [K8s Cluster Lifecycle Management]({{% relref "k8s_cluster_lifecycle_management" %}}). Before beginning this quick-start guide, ensure to complete the steps in the [Basic Configuration Guide]({{% relref "platform_services/oneks/getting_started/basic_configuration/" %}}). -{{< image path="/images/oneks/light/create_k8s_cluster_1.png" alt="OneKS create Cluster step 1" align="center" width="90%" mb="20px" >}} +Quick-start workflow: -Click **Create** to start the Cluster creation wizard. +* **Prepare the Environment**: [Verify the minimum OneKS, OneGate, networking, profile, and permission requirements]({{% relref "platform_services/oneks/getting_started/basic_configuration/" %}}). +* **Create the K8s Cluster**: Use the Sunstone Web UI K8s Cluster creation wizard. +* **Wait for the K8s Cluster**: Wait until the K8s Cluster reaches the `RUNNING` state. +* **Retrieve kubeconfig**: Copy the kubeconfig from the K8s Cluster detail view. +* **Validate Kubernetes Access**: Run `kubectl get nodes` using the retrieved kubeconfig. +* **Add Worker Capacity**: Create a node group if worker nodes are required. +* **Validate Workload Deployment**: Deploy a simple NGINX workload and test in-cluster service connectivity. + +## Create a New K8s Cluster + +From the left-hand navigation menu in Sunstone, go to **Kubernetes -> K8S Clusters**: + +{{< image path="/images/oneks/light/create_k8s_cluster_1.png" + pathDark="/images/oneks/dark/create_k8s_cluster_1.png" +alt="OneKS create Cluster step 1" align="center" width="90%" mb="20px" >}} + +Click **Create** to start the K8s Cluster creation wizard. The wizard guides you through the required configuration steps: -* **General**: Cluster name and optional description. +* **General**: K8s Cluster name and optional description. * **Select a Public Virtual Network**: Public network used for external connectivity and bootstrap paths. -* **Select a Private Virtual Network**: Private network used for internal Cluster communication. +* **Select a Private Virtual Network**: Private network used for internal K8s Cluster communication. * **Kubernetes Version**: Kubernetes version to deploy. * **Flavours**: Control-plane flavour to use. * **User inputs**: Remaining values required by the selected profile and flavour. -In the **General** step, provide the basic Cluster information. Enter a Cluster name and, optionally, a description. +In the **General** step, provide the basic K8s Cluster information. Enter a K8s Cluster name and, optionally, a description. -{{< image path="/images/oneks/light/create_k8s_cluster_2.png" alt="OneKS create Cluster general" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/create_k8s_cluster_2.png" + pathDark="/images/oneks/dark/create_k8s_cluster_2.png" +alt="OneKS create K8s Cluster general" align="center" width="90%" mb="20px" >}} -In **Select a Public Virtual Network**, select the public Virtual Network that will provide external connectivity for the Cluster. The public network acts as the gateway to the Internet and is used by the Cluster to expose external access where required. +In **Select a Public Virtual Network**, select the public Virtual Network that will provide external connectivity for the K8s Cluster. The public network acts as the gateway to the Internet and is used by the K8s Cluster to expose external access where required. -{{< image path="/images/oneks/light/create_k8s_cluster_3.png" alt="OneKS create Cluster public network" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/create_k8s_cluster_3.png" + pathDark="/images/oneks/dark/create_k8s_cluster_3.png" +alt="OneKS create K8s Cluster public network" align="center" width="90%" mb="20px" >}} -In **Select a Private Virtual Network**, select the private Virtual Network that will be used for internal Cluster communication. This network provides isolation from the public Internet and is used for communication between the Cluster nodes. +In **Select a Private Virtual Network**, select the private Virtual Network that will be used for internal K8s Cluster communication. This network provides isolation from the public Internet and is used for communication between the K8s Cluster nodes. -{{< image path="/images/oneks/light/create_k8s_cluster_4.png" alt="OneKS create Cluster private network" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/create_k8s_cluster_4.png" + pathDark="/images/oneks/dark/create_k8s_cluster_4.png" +alt="OneKS create K8s Cluster private network" align="center" width="90%" mb="20px" >}} In **Kubernetes Version**, select the Kubernetes version you intend to deploy. Only the versions available in the environment are shown. -{{< image path="/images/oneks/light/create_k8s_cluster_version.png" alt="OneKS create Cluster choose k8s version" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/create_k8s_cluster_version.png" + pathDark="/images/oneks/dark/create_k8s_cluster_version.png" +alt="OneKS create K8s Cluster choose k8s version" align="center" width="90%" mb="20px" >}} -In **Flavours**, select the control-plane flavour for the Cluster. The flavour defines the control-plane deployment model and the resources used by the control-plane nodes. +In **Flavours**, select the control-plane flavour for the K8s Cluster. The flavour defines the control-plane deployment model and the resources used by the control-plane nodes. Available options include: -* **Single-Node Control Plane**: Deploys one control-plane node. Suitable for development, evaluation, and non-critical workloads. +* **Single-node Control Plane**: Deploys one control-plane node. Suitable for development, evaluation, and non-critical workloads. * **Highly Available Control Plane**: Deploys three control-plane nodes with built-in redundancy. Suitable for production or environments that require higher availability. -{{< image path="/images/oneks/light/create_k8s_cluster_flavours.png" alt="OneKS create Cluster choose k8s version" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/create_k8s_cluster_flavours.png" + pathDark="/images/oneks/dark/create_k8s_cluster_flavours.png" +alt="OneKS create K8s Cluster choose k8s version" align="center" width="90%" mb="20px" >}} + +In **User Inputs**, review the remaining user input parameters required by the selected K8s Cluster configuration. + +After completing the required fields, finish the wizard to start K8s Cluster creation. You will be redirected to the **Kubernetes Logs** view, where you can monitor the provisioning process. + +During provisioning, the K8s Cluster initially appears with a `CREATING` or `PROVISIONING` status. The control-plane nodes are provisioned according to the selected flavour. This process typically takes several minutes. -In **User Inputs**, review the remaining user input parameters required by the selected Cluster configuration. +{{< image path="/images/oneks/light/k8s_logs_creating.png" + pathDark="/images/oneks/dark/k8s_logs_creating.png" +alt="OneKS create K8s Cluster choose k8s version" align="center" width="90%" mb="20px" >}} -After completing the required fields, finish the wizard to start Cluster creation. You will be redirected to the **Kubernetes Logs** view, where you can monitor the provisioning process. +You can check that the provisioning process is proceeding as expected on the Front-end command line using `onevm list`. Early in the provisioning process, you should see the [**Seed VM**]({{% relref "platform_services/oneks/getting_started/core_concepts/#seed-vm" %}}) in the `onevm list` output, this means that the provisioning process is proceeding as expected. + +```default +ID USER GROUP NAME STAT CPU MEM HOST TIME + 5 oneadmin oneadmin general-standalone-controlplane-3-seed prol 1 4G ubuntu2204-host 0d 00h00 +``` + +Run `onevm top` to view a continuously updated list of VMs, the seed VM will soon be accompanied by two further VMs, the virtual router and the control plane. This indicates that the provisioning process is proceeding as expected: + +```default +ID USER GROUP NAME STAT CPU MEM HOST TIME + 7 oneadmin oneadmin test-cluster-zx299 runn 2 4G ubuntu2204-host 0d 00h08 + 6 oneadmin oneadmin vr-test-cluster-cp-0 runn 1 512M ubuntu2204-host 0d 00h08 + 5 oneadmin oneadmin general-standalone-controlplane-3-seed prol 1 4G ubuntu2204-host 0d 00h00 +``` -During provisioning, the Cluster initially appears with a `CREATING` or `PROVISIONING` status. The control-plane nodes are provisioned according to the selected flavour. This process typically takes several minutes. +Continue waiting until the K8s Cluster reaches the `RUNNING` state in the Sunstone **Kubernetes Logs** view. -{{< image path="/images/oneks/light/k8s_logs_creating.png" alt="OneKS create Cluster choose k8s version" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/create_k8s_logs_running.png" + pathDark="/images/oneks/dark/create_k8s_logs_running.png" +alt="OneKS create K8s Cluster choose k8s version" align="center" width="90%" mb="20px" >}} -Wait until the Cluster reaches the `RUNNING` state. +You can verify that the K8s Cluster is running using the `onevm list` command on the Front-end command line. You should still see the two newly created VMs, one for the virtual router and one for the control plane. The seed VM will terminate upon completion of the process: -{{< image path="/images/oneks/light/create_k8s_logs_running.png" alt="OneKS create Cluster choose k8s version" align="center" width="90%" mb="20px" >}} +```default +ID USER GROUP NAME STAT CPU MEM HOST TIME + 2 oneadmin oneadmin test-cluster-nmhhb runn 2 4G ubuntu2204-kvm-ssh-ks-7-2-f1wvx-2.test 0d 03h26 + 1 oneadmin oneadmin vr-test-cluster-cp-0 runn 1 512M ubuntu2204-kvm-ssh-ks-7-2-f1wvx-1.test 0d 03h26 +``` ## Retrieve the Kubeconfig -After the Cluster reaches the `RUNNING` state, you can retrieve its kubeconfig from the Sunstone Web UI. +After the K8s Cluster reaches the `RUNNING` state, you can retrieve its kubeconfig from the Sunstone Web UI. The kubeconfig contains the details and credentials needed for kubectl to interact with the K8s Cluster to deploy applications, manage pods and troubleshoot. -From **Kubernetes -> K8S Clusters**, open the target Cluster. In the Cluster detail view, select the **Kubeconfig** tab. +From **Kubernetes -> K8S Clusters**, open the target K8s Cluster. In the K8s Cluster detail view, select the **Kubeconfig** tab. -{{< image path="/images/oneks/light/k8s_kubeconfig.png" alt="OneKS create Cluster choose k8s version" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/k8s_kubeconfig.png" + pathDark="/images/oneks/dark/k8s_kubeconfig.png" +alt="OneKS create K8s Cluster choose k8s version" align="center" width="90%" mb="20px" >}} -The kubeconfig content is displayed in the text area. Use the copy button to copy it, then save it locally as a file named `kubeconfig`. +The kubeconfig content is displayed in the text area. Use the copy button to copy it, then save it locally as a file named `kubeconfig`. This kubeconfig file must be used with all subsequent kubectl commands. -Use the kubeconfig with standard Kubernetes commands: +To use the kubeconfig file with kubectl commands, define the KUBECONFIG environment variable with an inline assignment before each command like so: ```shell KUBECONFIG=./kubeconfig kubectl get nodes ``` +You should see the newly created K8s Cluster control-plane node in the output: + +```default +NAME STATUS ROLES AGE VERSION +test-cluster-nmhhb Ready control-plane,etcd,master 3h22m v1.33.7+rke2r1 +``` + +You can also export the KUBECONFIG environment variable at the beginning of a terminal session: + +```shell +export KUBECONFIG=./kubeconfig +``` + +Then subsequent kubectl commands can be run without the inline environment variable assignment. Caution is advised with this approach when dealing simultaneously with multiple K8s Clusters (and therefore multiple kubeconfig files). + ## Add Worker Capacity -Node groups are the main operational unit for managing worker capacity in OneKS. After the Cluster is running, you can add worker capacity by creating a node group from the Sunstone Web UI. +Node groups are the main operational unit for managing worker capacity in OneKS. After the K8s Cluster is running, you can add worker capacity by creating a node group from the Sunstone Web UI. -From **Kubernetes -> K8S Clusters**, open the target Cluster. Select the **NodeGroup** tab, then click **Add Node Group**. +From **Kubernetes -> K8S Clusters**, open the target K8s Cluster. Select the **NodeGroup** tab, then click **Add Node Group**. -{{< image path="/images/oneks/light/k8s_add_node_group.png" alt="OneKS create Cluster choose k8s version" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/k8s_add_node_group.png" + pathDark="/images/oneks/dark/k8s_add_node_group.png" +alt="OneKS create K8s Cluster choose k8s version" align="center" width="90%" mb="20px" >}} -The node group creation wizard guides you through the required configuration steps: +The node-group creation wizard guides you through the required configuration steps: * **General**: Node group name and optional description. * **Flavours**: Worker node flavour. @@ -93,7 +166,9 @@ The node group creation wizard guides you through the required configuration ste In the **General** step, provide the basic node group information. Enter a node group name and, optionally, a description. -{{< image path="/images/oneks/light/k8s_node_group_name.png" alt="OneKS create Cluster choose k8s version" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/k8s_node_group_name.png" + pathDark="/images/oneks/dark/k8s_node_group_name.png" +alt="OneKS create K8s Cluster choose k8s version" align="center" width="90%" mb="20px" >}} In **Flavours**, select the worker node flavour. The flavour defines the resource profile that will be used to deploy the worker nodes in this node group. @@ -105,17 +180,23 @@ Available options include: Each flavour shows its default resource configuration, such as CPU, memory, and disk size. -{{< image path="/images/oneks/light/k8s_choose_flavours.png" alt="OneKS create Cluster choose k8s version" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/k8s_choose_flavours.png" + pathDark="/images/oneks/dark/k8s_choose_flavours.png" +alt="OneKS create K8s Cluster choose k8s version" align="center" width="90%" mb="20px" >}} In **User Inputs**, set the number of worker nodes to create. For example, set **Count** to `2` to create two worker nodes. The remaining fields, such as **CPU**, **Virtual CPU**, **Memory**, and **Disk Size**, are populated from the selected flavour. -{{< image path="/images/oneks/light/k8s_user_inputs.png" alt="OneKS create Cluster choose k8s version" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/k8s_user_inputs.png" + pathDark="/images/oneks/dark/k8s_user_inputs.png" +alt="OneKS create K8s Cluster choose k8s version" align="center" width="90%" mb="20px" >}} After finishing the wizard, you will be redirected to the **Kubernetes Logs** view, where you can monitor the node group provisioning process. -Wait until the node group reaches the `RUNNING` state and the Cluster returns to `RUNNING`. +Wait until the node group reaches the `RUNNING` state and the K8s Cluster returns to `RUNNING`. -{{< image path="/images/oneks/light/k8s_logs_adding_node_group.png" alt="OneKS create Cluster choose k8s version" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/k8s_logs_adding_node_group.png" + pathDark="/images/oneks/dark/k8s_logs_adding_node_group.png" +alt="OneKS create K8s Cluster choose k8s version" align="center" width="90%" mb="20px" >}} From the OpenNebula Front-end machine command line, verify the new worker nodes with: @@ -134,7 +215,7 @@ test-cluster-worker-2 Ready 3m v1.31.4 ## Validate Workload Deployment and Service Connectivity -After the Cluster nodes are in the `Ready` state, you can deploy a simple workload to verify that the Cluster is functioning correctly. +After the K8s Cluster nodes are in the `Ready` state, you can deploy a simple workload to verify that the K8s Cluster is functioning correctly. Create a test `NGINX` pod: @@ -161,7 +242,7 @@ NAME READY STATUS RESTARTS AGE IP NODE nginx-test 1/1 Running 0 27s 10.244.5.46 worker01 ``` -This confirms that the Cluster can schedule and start a workload on a worker node. +This confirms that the K8s Cluster can schedule and start a workload on a worker node. Expose the pod as a service: @@ -192,4 +273,14 @@ Accept-Ranges: bytes pod "curl-test" deleted from default namespace ``` -A `200` `OK` response confirms that the NGINX pod is running and reachable through the Kubernetes service. This test validates that basic workload scheduling, pod networking, DNS-based service discovery, and in-cluster connectivity are all working. +A `200` `OK` response confirms that the NGINX pod is running and reachable through the Kubernetes service. Completing this quick-start guide validates that basic workload scheduling, pod networking, DNS-based service discovery, and in-cluster connectivity are all working. + +## Next Steps + +Once you have completed this quick-start guide, you can move on to deploying K8s Clusters for real use cases. Next, read the [Core Concepts Guide]({{% relref "platform_services/oneks/getting_started/core_concepts/" %}}) to familiarize yourself with key OneKS concepts. Then consult the following references for more specific operation details: + +* [K8s Cluster Lifecycle Management]({{% relref "platform_services/oneks/management/k8s_cluster_lifecycle_management/" %}}) +* [Monitoring and Troubleshooting]({{% relref "platform_services/oneks/management/monitoring_and_troubleshooting/" %}}) +* [Configuration]({{% relref "platform_services/oneks/management/configuration/" %}}) +* [OneKS REST API]({{% relref "platform_services/oneks/references/oneks_api/" %}}) +* [OneKS CLI]({{% relref "platform_services/oneks/references/oneks_cli/" %}}) \ No newline at end of file diff --git a/content/platform_services/oneks/management/configuration.md b/content/platform_services/oneks/management/configuration.md index 18320542d..4ff92bfda 100644 --- a/content/platform_services/oneks/management/configuration.md +++ b/content/platform_services/oneks/management/configuration.md @@ -1,5 +1,5 @@ --- -title: "OneKS Cluster Configuration" +title: "OneKS K8s Cluster Configuration" linkTitle: "Configuration" date: "2026-05-12" description: @@ -21,9 +21,9 @@ The main runtime components include: * `oneks`: The user-facing CLI. * **ODS Log Controller**: Log management component. * **Event Manager**: Lifecycle event watcher. -* **Cluster Watchdog**: Cluster state monitoring component. +* **K8s Cluster Watchdog**: K8s Cluster state monitoring component. * **Seed VM Dependency**: Temporary managed VM used for control-plane bootstrap. -* **Cluster Router Dependency**: Router-related Cluster dependency. +* **K8s Cluster Router Dependency**: Router-related K8s Cluster dependency. By default, the OneKS server listens locally on Host `127.0.0.1` and port `10780`. @@ -37,7 +37,7 @@ http://127.0.0.1:10780/api/v1 Remote API access depends on how the service is exposed in the deployment. -OneKS manages OneKS Cluster documents and node-group documents, starts an event manager, and subscribes to OpenNebula lifecycle events. +OneKS manages OneKS K8s Cluster documents and node-group documents, starts an event manager, and subscribes to OpenNebula lifecycle events. Important runtime behavior includes: @@ -46,7 +46,7 @@ Important runtime behavior includes: * **Seed VM Readiness**: Tracks seed VM readiness through the `ONEKS_STATE` value. * **Router Monitoring**: Monitors virtual router allocation. * **Log Exposure**: Exposes per-cluster logs through the API and CLI. -* **State Reconciliation**: Reconciles Cluster and group state based on observed lifecycle events. +* **State Reconciliation**: Reconciles K8s Cluster and group state based on observed lifecycle events. Primary packaged paths: @@ -170,7 +170,7 @@ OneKS watches OpenNebula events and depends on: * **Subscriber Endpoint Connectivity**: Required for event-driven lifecycle tracking. * **Seed VM State Reporting**: Required for control-plane bootstrap progress. -* **Cluster Router Lifecycle Monitoring**: Required where the topology depends on routers. +* **K8s Cluster Router Lifecycle Monitoring**: Required where the topology depends on routers. * **TPROXY Support**: Required where services must be exposed through the public network gateway. Advanced configuration includes: diff --git a/content/platform_services/oneks/management/k8s_cluster_lifecycle_management.md b/content/platform_services/oneks/management/k8s_cluster_lifecycle_management.md index 090d53dad..bf30123a2 100644 --- a/content/platform_services/oneks/management/k8s_cluster_lifecycle_management.md +++ b/content/platform_services/oneks/management/k8s_cluster_lifecycle_management.md @@ -1,6 +1,6 @@ --- -title: "OneKS Cluster Lifecycle Management" -linkTitle: "Cluster Lifecycle Management" +title: "OneKS K8s Cluster Lifecycle Management" +linkTitle: "K8s Cluster Lifecycle Management" date: "2026-05-12" description: categories: @@ -9,24 +9,24 @@ weight: "1" type: docs --- -This section describes the main lifecycle operations for OneKS Clusters. It covers how to create, access, scale, upgrade, recover, and delete Clusters. +This section describes the main lifecycle operations for OneKS K8s Clusters. It covers how to create, access, scale, upgrade, recover, and delete K8s Clusters. -A OneKS Cluster lifecycle normally follows this sequence: +A OneKS K8s Cluster lifecycle normally follows this sequence: -* **Create a Cluster**: Provision the control plane and required infrastructure. -* **Access the Cluster**: Retrieve the kubeconfig and validate Kubernetes API access. +* **Create a K8s Cluster**: Provision the control plane and required infrastructure. +* **Access the K8s Cluster**: Retrieve the kubeconfig and validate Kubernetes API access. * **Add or Scale Worker Capacity**: Create or resize node groups. -* **Upgrade the Cluster**: Move the Cluster to a supported Kubernetes version. +* **Upgrade the K8s Cluster**: Move the K8s Cluster to a supported Kubernetes version. * **Recover Failed Operations**: Retry selected failed lifecycle actions. -* **Delete the Cluster**: Deprovision the Cluster and associated resources. +* **Delete the K8s Cluster**: Deprovision the K8s Cluster and associated resources. OneKS exposes these operations through the CLI, REST API, and Sunstone Web UI, depending on the deployment and user permissions. -## Creating a Cluster +## Creating a K8s Cluster -Creating a Cluster provisions the Kubernetes control plane and the supporting OpenNebula infrastructure required by the selected Cluster profile. +Creating a K8s Cluster provisions the Kubernetes control plane and the supporting OpenNebula infrastructure required by the selected K8s Cluster profile. -Before creating a Cluster, verify that: +Before creating a K8s Cluster, verify that: * **OneKS Service**: The OneKS service is configured and running. * **OneGate Service**: OneGate is configured and reachable. @@ -39,9 +39,9 @@ Before creating a Cluster, verify that: For more detailed information refer to the [Basic Configuration Guide]({{% relref "platform_services/oneks/getting_started/basic_configuration" %}}). -### Create a Cluster Interactively with the CLI +### Create a K8s Cluster Interactively with the CLI -Before creating a Cluster with the CLI, identify the IDs of the OpenNebula public and private Virtual Networks. These networks are used to provide connectivity between OpenNebula, the virtual router, and the Kubernetes Cluster, while preserving network isolation. +Before creating a K8s Cluster with the CLI, identify the IDs of the OpenNebula public and private Virtual Networks. These networks are used to provide connectivity between OpenNebula, the virtual router, and the K8s Cluster, while preserving network isolation. List the available Virtual Networks with: @@ -54,23 +54,23 @@ ID USER GROUP NAME CLUSTERS BRIDGE STATE 0 oneadmin oneadmin public 0 br1 rdy ``` -Then launch the interactive Cluster creation command: +Then launch the interactive K8s Cluster creation command: ```shell oneks create cluster --wait ``` -This starts an interactive Cluster creation flow and waits until the operation completes or reaches a terminal state. You will be asked to provide the following parameters: +This starts an interactive K8s Cluster creation flow and waits until the operation completes or reaches a terminal state. You will be asked to provide the following parameters: -* **Cluster Name**: The name used to identify the OneKS Cluster. +* **K8s Cluster Name**: The name used to identify the OneKS K8s Cluster. * **Kubernetes Version**: The Kubernetes version to deploy. -* **Cluster Flavour**: The control-plane flavour, such as `standalone` or `ha`. -* **Public Network ID**: The OpenNebula public Virtual Network used by the Cluster. -* **Private Network ID**: The OpenNebula private Virtual Network used by the Cluster. +* **K8s Cluster Flavour**: The control-plane flavour, such as `standalone` or `ha`. +* **Public Network ID**: The OpenNebula public Virtual Network used by the K8s Cluster. +* **Private Network ID**: The OpenNebula private Virtual Network used by the K8s Cluster. {{< image path="/images/oneks/light/k8s_cluster_create_cli.png" alt="K8s Cluster create CLI menu" align="center" width="60%" mb="20px" >}} -After the Cluster is created, wait until its status changes from `PROVISIONING` to `RUNNING`. +After the K8s Cluster is created, wait until its status changes from `PROVISIONING` to `RUNNING`. You can then validate that the virtual router and control plane VM have been created: @@ -84,7 +84,7 @@ ID USER GROUP NAME STAT CPU MEM HOST 0 oneadmin oneadmin vr-test-cluster-cp-0 runn 1 512M ubuntu2204-kvm-ssh-ks-7-3-kxu7a-1.test ``` -You can also create a Cluster from a JSON specification with the CLI: +You can also create a K8s Cluster from a JSON specification with the CLI: ```shell oneks create cluster --file spec.json --wait @@ -107,9 +107,9 @@ Example `spec.json`: } ``` -### Create a Cluster with the API +### Create a K8s Cluster with the API -You can create a Cluster with the API using the following command: +You can create a K8s Cluster with the API using the following command: ```shell curl -u "$(cat /var/lib/one/.one/one_auth)" \ @@ -148,7 +148,7 @@ Example request body: Required fields: -* `name`: Cluster name. +* `name`: K8s Cluster name. * `kubernetes_version`: Kubernetes version to deploy. * `public_network`: OpenNebula public Virtual Network ID. * `private_network`: OpenNebula private Virtual Network ID. @@ -156,7 +156,7 @@ Required fields: Optional fields: -* `description`: Cluster description. +* `description`: K8s Cluster description. * `spec.name`: Control-plane group name. * `spec.description`: Control-plane group description. * `spec.family`: Profile family. If omitted, the default family is used. @@ -164,13 +164,13 @@ Optional fields: The `spec` object selects the family and flavour used for the control-plane group. Flavour defaults are combined with any provided user input values according to the profile override rules. -### Create a Cluster with the Sunstone Web UI +### Create a K8s Cluster with the Sunstone Web UI -For the Sunstone Web UI, use the Cluster creation wizard described in the [Getting Started with OneKS Quick-start Guide]({{% relref "platform_services/oneks/getting_started/quick_start/" %}}). +For the Sunstone Web UI, use the K8s Cluster creation wizard described in the [Getting Started with OneKS Quick-start Guide]({{% relref "platform_services/oneks/getting_started/quick_start/" %}}). -## Accessing a Cluster +## Accessing a K8s Cluster -After the Cluster reaches the `RUNNING` state, retrieve its kubeconfig. The kubeconfig contains the Kubernetes API endpoint and credentials required to access the Cluster. +After the K8s Cluster reaches the `RUNNING` state, retrieve its kubeconfig. The kubeconfig contains the Kubernetes API endpoint and credentials required to access the K8s Cluster. ### Retrieve the kubeconfig with the CLI @@ -194,13 +194,15 @@ Use the saved kubeconfig with `kubectl`. ### Retrieve the kubeconfig with the Sunstone Web UI -* **Cluster Detail View**: Open the target Cluster. +* **K8s Cluster Detail View**: Open the target K8s Cluster. * **Kubeconfig Tab**: Copy the kubeconfig content. * **Local File**: Save it as `kubeconfig`. -{{< image path="/images/oneks/light/k8s_kubeconfig.png" alt="OneKS create Cluster choose k8s version" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/k8s_kubeconfig.png" + pathDark="/images/oneks/dark/k8s_kubeconfig.png" +alt="OneKS create K8s Cluster choose k8s version" align="center" width="90%" mb="20px" >}} -**Cluster validation**: run `kubectl get nodes` with the retrieved kubeconfig. +**K8s Cluster validation**: run `kubectl get nodes` with the retrieved kubeconfig. Example output in all cases: @@ -215,7 +217,7 @@ The command should show the control-plane nodes in a `Ready` state. Scaling worker capacity is done by creating or resizing node groups. -Node groups are the main operational unit for managing worker capacity in OneKS. Scaling should be performed against node groups, not directly against the Cluster control plane. +Node groups are the main operational unit for managing worker capacity in OneKS. Scaling should be performed against node groups, not directly against the K8s Cluster control plane. ### Create a Node Group with the CLI @@ -308,19 +310,19 @@ test-cluster-worker-2 Ready 2m v1.31.4 test-cluster-worker-3 Ready 2m v1.31.4 ``` -## Upgrading a Cluster +## Upgrading a K8s Cluster OneKS supports Kubernetes version upgrades for versions supported by the selected profile family. Before upgrading, verify that: * **Target Version**: The target Kubernetes version is supported by the selected family. -* **Cluster State**: The Cluster is in a suitable operational state. +* **K8s Cluster State**: The K8s Cluster is in a suitable operational state. * **Profiles**: The selected profiles support the target version. * **Workloads**: Running workloads have been reviewed according to the user’s upgrade policy. * **Backups**: Any required backups or recovery procedures have been completed. -### Upgrade a Cluster with the CLI +### Upgrade a K8s Cluster with the CLI ```shell oneks upgrade cluster --k8s-version @@ -332,7 +334,7 @@ Example: oneks upgrade cluster 42 --k8s-version v1.32.9 ``` -After the upgrade starts, inspect the Cluster state: +After the upgrade starts, inspect the K8s Cluster state: ```shell oneks show cluster 42 @@ -344,7 +346,7 @@ Validate the Kubernetes nodes: KUBECONFIG=./kubeconfig kubectl get nodes -o wide ``` -### Upgrade a Cluster with the API +### Upgrade a K8s Cluster with the API ```shell curl -u "$(cat /var/lib/one/.one/one_auth)" \ @@ -359,14 +361,14 @@ The request must include the target Kubernetes version according to the API sche After a lifecycle operation, validate both OneKS state and Kubernetes state. -Use OneKS to check whether the Cluster and groups are healthy: +Use OneKS to check whether the K8s Cluster and groups are healthy: ```shell oneks show cluster oneks list nodegroups ``` -Then validate the Kubernetes Cluster directly: +Then validate the K8s Cluster directly: ```shell KUBECONFIG=./kubeconfig kubectl get nodes -o wide @@ -374,7 +376,7 @@ KUBECONFIG=./kubeconfig kubectl get nodes -o wide A successful node-group creation or scale operation should result in the node group reaching `RUNNING` in OneKS and the expected worker nodes appearing as `Ready` in Kubernetes. -If the Kubernetes nodes are `Ready` but the OneKS Cluster is in `WARNING`, inspect the failed group state and Cluster logs: +If the Kubernetes nodes are `Ready` but the OneKS K8s Cluster is in `WARNING`, inspect the failed group state and K8s Cluster logs: ```shell oneks show cluster @@ -383,17 +385,19 @@ oneks logs cluster A `WARNING` state means one or more underlying groups are degraded or failed, even if the Kubernetes API remains reachable. -### Upgrade a Cluster with Sunstone +### Upgrade a K8s Cluster with Sunstone -In the **K8S Clusters** view, select the Cluster you want to upgrade. Open the **Info** tab and scroll to the **Kubernetes Version** field. +In the **K8S Clusters** view, select the K8s Cluster you want to upgrade. Open the **Info** tab and scroll to the **Kubernetes Version** field. Use the dropdown menu to select the target Kubernetes version, then confirm the upgrade. -The selected version must be supported by the Cluster profile. After starting the upgrade, monitor the Cluster state and logs until the Cluster returns to `RUNNING`. +The selected version must be supported by the K8s Cluster profile. After starting the upgrade, monitor the K8s Cluster state and logs until the K8s Cluster returns to `RUNNING`. -{{< image path="/images/oneks/light/k8s_upgrade_cluster_sunstone.png" alt="OneKS upgrade cluster Sunstone" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/k8s_upgrade_cluster_sunstone.png" + pathDark="/images/oneks/dark/k8s_upgrade_cluster_sunstone.png" +alt="OneKS upgrade cluster Sunstone" align="center" width="90%" mb="20px" >}} -## Recovering a Cluster or Node Group +## Recovering a K8s Cluster or Node Group OneKS includes recovery actions for selected failure and warning states. @@ -401,7 +405,7 @@ Recovery retries the failed lifecycle operation where possible. It may also retr Recovery is not a general rollback mechanism. It should not be assumed to fix every infrastructure, dependency, or Kubernetes-level failure. -### Recover a Cluster with the CLI +### Recover a K8s Cluster with the CLI ```shell oneks recover cluster @@ -413,7 +417,7 @@ oneks recover cluster oneks recover nodegroup ``` -### Recover a Cluster with the API +### Recover a K8s Cluster with the API ```shell curl -u "$(cat /var/lib/one/.one/one_auth)" \ @@ -437,11 +441,13 @@ oneks logs cluster ### Recover a Node group with Sunstone -In the **K8S Clusters** view, select the Cluster that contains the affected node group. Open the **NodeGroup** tab and locate the node group you want to recover. Click the **Recover Node Group** action button on the node group row. +In the **K8S Clusters** view, select the K8s Cluster that contains the affected node group. Open the **NodeGroup** tab and locate the node group you want to recover. Click the **Recover Node Group** action button on the node group row. -The recovery action retries the last failed lifecycle operation where possible. It is intended for node groups in a warning or failure state, such as `PROVISIONING_FAILURE`, `SCALING_FAILURE`, or `WARNING`. After starting the recovery, monitor the Cluster logs and node group state until the node group returns to `RUNNING`. +The recovery action retries the last failed lifecycle operation where possible. It is intended for node groups in a warning or failure state, such as `PROVISIONING_FAILURE`, `SCALING_FAILURE`, or `WARNING`. After starting the recovery, monitor the K8s Cluster logs and node group state until the node group returns to `RUNNING`. -{{< image path="/images/oneks/light/k8s_recover_nodegroup_sunstone.png" alt="OneKS recover nodegroup Sunstone" align="center" width="90%" mb="20px" >}} +{{< image path="/images/oneks/light/k8s_recover_nodegroup_sunstone.png" + pathDark="/images/oneks/dark/k8s_recover_nodegroup_sunstone.png" +alt="OneKS recover nodegroup Sunstone" align="center" width="90%" mb="20px" >}} After recovery, inspect the affected resource and review logs: @@ -451,11 +457,11 @@ oneks show nodegroup oneks logs cluster ``` -## Deleting a Cluster +## Deleting a K8s Cluster -Deleting a Cluster deprovisions the OneKS Cluster and its managed resources. +Deleting a K8s Cluster deprovisions the OneKS K8s Cluster and its managed resources. -### Delete a Cluster with the CLI +### Delete a K8s Cluster with the CLI ```shell oneks delete cluster @@ -467,22 +473,24 @@ Force deletion, if required: oneks delete cluster --force ``` +{{< alert title="Caution!" type="warning" >}} Use force deletion cautiously. It may skip parts of the normal deprovisioning workflow and can leave infrastructure that requires manual cleanup. +{{< /alert >}} -### Delete a Cluster with the API +### Delete a K8s Cluster with the API ```shell curl -u "$(cat /var/lib/one/.one/one_auth)" \ -X DELETE "http://:10780/api/v1/clusters/?force=true" ``` -### Delete a Cluster with Sunstone +### Delete a K8s Cluster with Sunstone -In the **K8S Clusters** view, select the Cluster you want to delete. Click the red **Delete** button next to the **Create** button. +In the **K8S Clusters** view, select the K8s Cluster you want to delete. Click the red **Delete** button next to the **Create** button. -The deletion operation deprovisions the OneKS Cluster and its managed resources, including the control plane and managed node groups. Referenced infrastructure, such as the public and private Virtual Networks selected during Cluster creation, is not normally deleted by OneKS. +The deletion operation deprovisions the OneKS K8s Cluster and its managed resources, including the control plane and managed node groups. Referenced infrastructure, such as the public and private Virtual Networks selected during K8s Cluster creation, is not normally deleted by OneKS. -After deletion, verify that the Cluster no longer appears in OneKS: +After deletion, verify that the K8s Cluster no longer appears in OneKS: ```shell oneks list clusters @@ -496,7 +504,7 @@ onevrouter list onetemplate list ``` -If deletion fails, inspect the Cluster logs: +If deletion fails, inspect the K8s Cluster logs: ```shell oneks logs cluster diff --git a/content/platform_services/oneks/management/monitoring_and_troubleshooting.md b/content/platform_services/oneks/management/monitoring_and_troubleshooting.md index e29e3c076..b02290486 100644 --- a/content/platform_services/oneks/management/monitoring_and_troubleshooting.md +++ b/content/platform_services/oneks/management/monitoring_and_troubleshooting.md @@ -1,5 +1,5 @@ --- -title: "OneKS Cluster Monitoring and Troubleshooting" +title: "OneKS K8s Cluster Monitoring and Troubleshooting" linkTitle: "Monitoring and Troubleshooting" date: "2026-05-12" description: @@ -13,26 +13,26 @@ OneKS uses event-based monitoring to follow VM provisioning, deprovisioning, and Event-driven monitoring is implemented through OpenNebula VM and dependency event watchers. It tracks VM allocation and state changes, seed VM state changes, and dependency lifecycle changes. -## Cluster States +## K8s Cluster States -OneKS exposes the following Cluster states: +OneKS exposes the following K8s Cluster states: -* `PENDING`: A Cluster document has been created. +* `PENDING`: A K8s Cluster document has been created. * `PROVISIONING`: Control-plane provisioning has started. * `RUNNING`: All expected groups are running. * `SCALING`: A node group is being added, removed, or resized. -* `UPGRADING`: The Cluster version is being upgraded. -* `DEPROVISIONING`: The Cluster resources are being deleted. +* `UPGRADING`: The K8s Cluster version is being upgraded. +* `DEPROVISIONING`: The K8s Cluster resources are being deleted. * `WARNING`: One or more groups are inconsistent or degraded. -* `DONE`: Cluster deprovisioning has completed. +* `DONE`: K8s Cluster deprovisioning has completed. * `PROVISIONING_FAILURE`: Provisioning failed. * `SCALING_FAILURE`: Scaling failed. * `UPGRADING_FAILURE`: Upgrade failed. * `DEPROVISIONING_FAILURE`: Deprovisioning failed. -A Cluster reaches the `RUNNING` state when all expected groups are running. A Cluster receives a `WARNING` state when one or more groups are warned or failed while the Cluster resource itself is otherwise still present. During deprovisioning, when managed groups have been removed, the Cluster reaches `DONE` and is deleted from storage by the action code. +A K8s Cluster reaches the `RUNNING` state when all expected groups are running. A K8s Cluster receives a `WARNING` state when one or more groups are warned or failed while the K8s Cluster resource itself is otherwise still present. During deprovisioning, when managed groups have been removed, the K8s Cluster reaches `DONE` and is deleted from storage by the action code. -During control-plane bootstrapping, seed VM failures can surface as `BOOTSTRAPPING_FAILURE` on the control-plane group. The Cluster is then notified of the group failure according to the normal reconciliation behavior. +During control-plane bootstrapping, seed VM failures can surface as `BOOTSTRAPPING_FAILURE` on the control-plane group. The K8s Cluster is then notified of the group failure according to the normal reconciliation behavior. ## Node Group States @@ -59,12 +59,12 @@ A node-group warning may indicate that one or more associated VMs or dependencie OneKS reconciliation follows these general rules: -* **Cluster Running Condition**: If all expected groups are `RUNNING`, the Cluster reconciles to `RUNNING`. -* **Group Degradation**: Group-level warnings or failures may surface at Cluster level as `WARNING` when the Cluster resource itself is still present but one or more underlying groups are degraded. -* **Action-specific Failures**: Group failures may map to Cluster failure states depending on the Cluster action in progress. -* **Deprovisioning Completion**: During deprovisioning, when managed groups have been removed, the Cluster reaches `DONE`. +* **K8s Cluster Running Condition**: If all expected groups are `RUNNING`, the K8s Cluster reconciles to `RUNNING`. +* **Group Degradation**: Group-level warnings or failures may surface at K8s Cluster level as `WARNING` when the K8s Cluster resource itself is still present but one or more underlying groups are degraded. +* **Action-specific Failures**: Group failures may map to K8s Cluster failure states depending on the K8s Cluster action in progress. +* **Deprovisioning Completion**: During deprovisioning, when managed groups have been removed, the K8s Cluster reaches `DONE`. * **Terminal State**: `DONE` is a terminal lifecycle state reached during deprovisioning. -* **Node Group Creation**: Node groups can be added only when the Cluster is in an appropriate operational state and the control plane is running. +* **Node Group Creation**: Node groups can be added only when the K8s Cluster is in an appropriate operational state and the control plane is running. * **Control-plane Scaling**: The control plane does not support scale operations through the OneKS scale command. ## Troubleshooting Logs @@ -97,15 +97,15 @@ API: curl -u "$(cat /var/lib/one/.one/one_auth)" http://:10780/api/v1/clusters//logs ``` -Service logs are useful for troubleshooting the OneKS daemon. Per-cluster logs are useful for troubleshooting lifecycle operations for a specific Cluster. CLI and API log retrieval provide user-facing paths for inspecting Cluster lifecycle logs. +Service logs are useful for troubleshooting the OneKS daemon. Per-cluster logs are useful for troubleshooting lifecycle operations for a specific K8s Cluster. CLI and API log retrieval provide user-facing paths for inspecting K8s Cluster lifecycle logs. ## Provisioning Troubleshooting -Cluster provisioning can fail for different infrastructure or network-related reasons. In most cases, these failures surface as a timeout during provisioning and the Cluster eventually moves to `PROVISIONING_FAILURE`. The following checks can help identify the most common causes. +K8s Cluster provisioning can fail for different infrastructure or network-related reasons. In most cases, these failures surface as a timeout during provisioning and the K8s Cluster eventually moves to `PROVISIONING_FAILURE`. The following checks can help identify the most common causes. ### OneGate is Not Properly Configured -OneKS relies on the seed VM to report progress and update OpenNebula resources during provisioning. If OneGate is not properly configured or the seed VM cannot reach the OneGate service, the seed VM cannot publish the expected updates back to OpenNebula. As a result, OneKS waits until the provisioning timeout is reached and the Cluster enters `PROVISIONING_FAILURE`. +OneKS relies on the seed VM to report progress and update OpenNebula resources during provisioning. If OneGate is not properly configured or the seed VM cannot reach the OneGate service, the seed VM cannot publish the expected updates back to OpenNebula. As a result, OneKS waits until the provisioning timeout is reached and the K8s Cluster enters `PROVISIONING_FAILURE`. Check that the OneGate service is running on the OpenNebula Front-end: @@ -127,7 +127,7 @@ For more information, refer to the [OpenNebula OneGate Documentation]({{% relref ### VMs Cannot Access the Internet -During provisioning, the seed VM needs Internet access to download the required artifacts and images used to bootstrap and connect the Kubernetes nodes. If the seed VM or the target nodes cannot reach the Internet, provisioning may stall until the timeout is reached and the Cluster moves to `PROVISIONING_FAILURE`. +During provisioning, the seed VM needs Internet access to download the required artifacts and images used to bootstrap and connect the Kubernetes nodes. If the seed VM or the target nodes cannot reach the Internet, provisioning may stall until the timeout is reached and the K8s Cluster moves to `PROVISIONING_FAILURE`. From the affected VM, check basic network connectivity: @@ -141,13 +141,13 @@ Then check DNS resolution: getent hosts opennebula.io ``` -If IP connectivity works but DNS resolution fails, review the DNS configuration assigned to the VM. If both fail, review the router, gateway, NAT, and security group configuration of the public Virtual Network that the Cluster has assigned. +If IP connectivity works but DNS resolution fails, review the DNS configuration assigned to the VM. If both fail, review the router, gateway, NAT, and security group configuration of the public Virtual Network that the K8s Cluster has assigned. For more information, refer to the [OpenNebula Virtual Networks Documentation]({{% relref "product/cluster_configuration/networking_system/manage_vnets/" %}}). ### VMs Cannot Communicate Through the Private Networks -The seed VM must be able to reach the control-plane VM through the private Cluster network. If the private VNet is not correctly configured, the seed VM may create the control-plane VM successfully but fail when trying to connect to it and pivot the management Cluster. +The seed VM must be able to reach the control-plane VM through the private K8s Cluster network. If the private VNet is not correctly configured, the seed VM may create the control-plane VM successfully but fail when trying to connect to it and pivot the management K8s Cluster. This usually indicates an issue in the private network configuration, such as missing routing, incorrect address assignment, security group restrictions, or lack of connectivity between the seed VM and the Kubernetes node private IPs. @@ -163,7 +163,7 @@ Check whether SSH is reachable: nc -vz 22 ``` -If the control-plane VM is reachable only through the Cluster virtual router created by OneKS, connect through the router as a jump Host: +If the control-plane VM is reachable only through the K8s Cluster virtual router created by OneKS, connect through the router as a jump Host: ```shell ssh -J root@ root@ @@ -175,7 +175,7 @@ For more information, see the OpenNebula Virtual Networks documentation. ## Basic Kubernetes Troubleshooting -Kubernetes-level checks are Cluster-specific. Start by retrieving the kubeconfig for the target Cluster: +Kubernetes-level checks are Cluster-specific. Start by retrieving the kubeconfig for the target K8s Cluster: ```shell oneks show cluster --kubeconfig > kubeconfig @@ -187,7 +187,7 @@ Then verify the Kubernetes node state: KUBECONFIG=./kubeconfig kubectl get nodes -o wide ``` -A healthy Cluster should show the expected control-plane and worker nodes in a `Ready` state. +A healthy K8s Cluster should show the expected control-plane and worker nodes in a `Ready` state. If one or more nodes are `NotReady`, identify the affected OneKS group and OpenNebula VM: @@ -199,7 +199,7 @@ oneks show nodegroup The OneKS output shows the VM IDs associated with the control-plane and each node group. -The OpenNebula Front-end cannot reach the Kubernetes node private network directly, connect through the Cluster virtual router. +The OpenNebula Front-end cannot reach the Kubernetes node private network directly, connect through the K8s Cluster virtual router. Identify the virtual router VM: diff --git a/content/platform_services/oneks/references/oneks_api.md b/content/platform_services/oneks/references/oneks_api.md index 385a0cc36..164e2fdb6 100644 --- a/content/platform_services/oneks/references/oneks_api.md +++ b/content/platform_services/oneks/references/oneks_api.md @@ -9,7 +9,7 @@ weight: "1" type: swagger --- -The OpenNebula OneKS API is a RESTful service for managing Kubernetes infrastructure on OpenNebula. It allows users to create and manage Kubernetes Clusters, operate nodegroups, retrieve Cluster information, and trigger lifecycle actions such as scaling and upgrades. All data is sent and received in JSON format. +The OpenNebula OneKS API is a RESTful service for managing Kubernetes infrastructure on OpenNebula. It allows users to create and manage Kubernetes Clusters, operate nodegroups, retrieve K8s Cluster information, and trigger lifecycle actions such as scaling and upgrades. All data is sent and received in JSON format. This guide is intended for developers and integrators. For other purposes, OneKS is accessible via its own [OneKS Command Line Interface]({{% relref "/product/operation_references/command_line_interface/cli.md#oneform-commands" %}}). diff --git a/content/platform_services/oneks/references/oneks_cli.md b/content/platform_services/oneks/references/oneks_cli.md index 98d1b084d..0fcbfb2a5 100644 --- a/content/platform_services/oneks/references/oneks_cli.md +++ b/content/platform_services/oneks/references/oneks_cli.md @@ -19,12 +19,12 @@ oneks [] [] Product-facing resources are: -* `cluster`: OneKS Cluster resource. -* `nodegroup`: Worker-capacity group attached to a Cluster. +* `cluster`: OneKS K8s Cluster resource. +* `nodegroup`: Worker-capacity group attached to a K8s Cluster. The CLI may also expose plural forms: -* `clusters`: List or top Cluster resources. +* `clusters`: List or top K8s Cluster resources. * `nodegroups`: List or top node-group resources. Important command naming note: @@ -33,28 +33,28 @@ Some builds may expose node groups through the lower-level `group` resource in C ## Common commands -* `oneks list clusters`: List Clusters. +* `oneks list clusters`: List K8s Clusters. * `oneks list nodegroups`: List node groups. -* `oneks top clusters`: Continuously display Cluster status. +* `oneks top clusters`: Continuously display K8s Cluster status. * `oneks top nodegroups`: Continuously display node-group status. -* `oneks show cluster `: Show detailed Cluster information. +* `oneks show cluster `: Show detailed K8s Cluster information. * `oneks show nodegroup `: Show detailed node-group information. * `oneks create cluster`: Create a cluster. * `oneks create nodegroup --cluster-id `: Create a node group. -* `oneks recover cluster `: Recover a Cluster from selected failure states. +* `oneks recover cluster `: Recover a K8s Cluster from selected failure states. * `oneks recover nodegroup `: Recover a node group from selected failure states. -* `oneks delete cluster `: Delete a Cluster. +* `oneks delete cluster `: Delete a K8s Cluster. * `oneks delete nodegroup `: Delete a node group. -* `oneks logs cluster `: Show Cluster logs. -* `oneks upgrade cluster --k8s-version `: Upgrade a Cluster version. +* `oneks logs cluster `: Show K8s Cluster logs. +* `oneks upgrade cluster --k8s-version `: Upgrade a K8s Cluster version. * `oneks scale nodegroup --target `: Scale a node group. -* `oneks chgrp cluster `: Change Cluster group ownership. -* `oneks chown cluster `: Change Cluster owner and group. -* `oneks chmod cluster `: Change Cluster permissions. +* `oneks chgrp cluster `: Change K8s Cluster group ownership. +* `oneks chown cluster `: Change K8s Cluster owner and group. +* `oneks chmod cluster `: Change K8s Cluster permissions. ## Common Examples -Create and access a Cluster: +Create and access a K8s Cluster: ```shell oneks create cluster --wait @@ -80,13 +80,13 @@ oneks create nodegroup --cluster-id 42 oneks scale nodegroup 7 --target 3 ``` -Upgrade a Cluster: +Upgrade a K8s Cluster: ```shell oneks upgrade cluster 42 --k8s-version v1.32.9 ``` -Recover a Cluster or node group: +Recover a K8s Cluster or node group: ```shell oneks recover cluster 42 @@ -100,14 +100,14 @@ oneks logs cluster 42 oneks logs cluster 42 --follow ``` -Delete a Cluster: +Delete a K8s Cluster: ```shell oneks delete cluster 42 oneks delete cluster 42 --force ``` -Administrative Cluster operations: +Administrative K8s Cluster operations: ```shell oneks rename cluster 42 new-name diff --git a/content/software/installation_process/cluster_installation/lxc_node_installation.md b/content/software/installation_process/cluster_installation/lxc_node_installation.md index b71addbab..07fe4830f 100644 --- a/content/software/installation_process/cluster_installation/lxc_node_installation.md +++ b/content/software/installation_process/cluster_installation/lxc_node_installation.md @@ -43,34 +43,47 @@ Refer to [OpenNebula Repositories]({{% relref "opennebula_repository_configurati OpenNebula depends on packages which aren’t in the base distribution repositories. Execute one of the commands below (distinguished by the Host platform) to configure access to additional [EPEL](https://fedoraproject.org/wiki/EPEL) (Extra Packages for Enterprise Linux) repository: -**AlmaLinux 9, 10** +{{< tabpane text=true right=false >}} +{{% tab header="**OS**:" disabled=true /%}} +{{% tab header="**AlmaLinux 9, 10**"%}} +### AlmaLinux 9, 10 ```shell yum -y install epel-release ``` +{{% /tab %}} -**RHEL 9** +{{% tab header="RHEL 9"%}} +### RHEL 9 ```shell rpm -ivh https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm ``` +{{% /tab %}} +{{< /tabpane >}} ### Install OpenNebula LXC Node Package Execute the following commands to install the OpenNebula LXC Node package: +{{< tabpane text=true right=false >}} +{{% tab header="**OS**:" disabled=true /%}} +{{% tab header="AlmaLinux/RHEL"%}} #### Installing on AlmaLinux/RHEL ```shell yum -y install opennebula-node-lxc ``` - +{{% /tab %}} +{{% tab header="Debian/Ubuntu"%}} #### Installing on Debian/Ubuntu ```shell apt-get update apt-get -y install opennebula-node-lxc ``` +{{% /tab %}} +{{< /tabpane >}} Install the suggested package `rbd-nbd` if the Ceph Datastore is going to be used by the LXC Hosts. For further configuration check the specific [guide]({{% relref "lxc_driver#lxcmg" %}}). @@ -92,7 +105,8 @@ Depending on your OpenNebula deployment type, the following may be required on y ```shell setsebool -P virt_use_nfs on -```{{< /alert >}} +``` +{{< /alert >}} ## Step 4. Configure Passwordless SSH @@ -179,10 +193,10 @@ scp -p /var/lib/one/.ssh/id_rsa :/var/lib/one/.ssh/ You should verify that none of these connections (under user `oneadmin`) fail and none require a password: -* from the Front-end to Front-end itself -* from the Front-end to all nodes -* from all nodes to all nodes -* from all nodes back to Front-end +* From the Front-end to Front-end itself +* From the Front-end to all nodes +* From all nodes to all nodes +* From all nodes back to Front-end For example, execute on the Front-end: @@ -263,19 +277,26 @@ Learn more in [Hosts and Clusters Management]({{% relref "../../../product/clust {{< alert title="Note" type="info" >}} If the host turns to `err` state instead of `on`, check OpenNebula log `/var/log/one/oned.log`. The problem might be with connecting over SSH.{{< /alert >}} +{{< tabpane text=true right=false >}} +{{% tab header="**Interface**:" disabled=true /%}} + +{{% tab header="Sunstone"%}} ### Add Host with Sunstone Open Sunstone as documented [here]({{% relref "frontend_install#verify-frontend-section-sunstone" %}}). On the left side menu go to **Infrastructure** → **Hosts**. Click on the `+` button. -![sunstone_select_create_host](/images/sunstone_select_create_host.png) +{{< image path="/images/sunstone_select_create_host.png" alt="Sunstone select create host" align="center" width="90%" mb="20px" >}} Then fill in the hostname, FQDN, or IP of the node in the `Hostname` field. -![sunstone_create_host_dialog](/images/sunstone_create_host_dialog_lxc.png) +{{< image path="/images/sunstone_create_host_dialog_lxc.png" alt="Sunstone select create host dialog" align="center" width="90%" mb="20px" >}} Finally, return back to the **Hosts** list, and check that the Host has switched to `ON` status. It can take up to one minute. You can click on the refresh button to check the status more frequently. -![sunstone_list_hosts](/images/sunstone_list_hosts.png) +{{< image path="/images/sunstone_list_hosts.png" alt="Sunstone select list hosts" align="center" width="90%" mb="20px" >}} + +{{% /tab %}} +{{% tab header="CLI"%}} ### Add Host with CLI @@ -294,10 +315,12 @@ onehost list ID NAME CLUSTER RVM ALLOCATED_CPU ALLOCATED_MEM STAT 0 node01 default 0 0 / 400 (0%) 0K / 7.7G (0%) on ``` +{{% /tab %}} +{{< /tabpane >}} ## Next steps Now, you can continue by controlling and extending your cloud: -- Configuring [Storage]({{% relref "../../../product/cluster_configuration/storage_system/overview" %}}) and [Networking]({{% relref "../../../product/cluster_configuration/networking_system/overview" %}}) -- Exploring the [Product]({{% relref "product/index" %}}) guides, such as [Control Plane Configuration]({{% relref "product/control_plane_configuration/index" %}}), [Cloud Cluster Configuration]({{% relref "product/cluster_configuration/index" %}}) and [Virtual Machines Operation]({{% relref "product/virtual_machines_operation/index" %}}) +- Configuring [Storage]({{% relref "../../../product/cluster_configuration/storage_system/overview" %}}) and [Networking]({{% relref "../../../product/cluster_configuration/networking_system/overview" %}}). +- Exploring the [Product]({{% relref "product/index" %}}) guides, such as [Control Plane Configuration]({{% relref "product/control_plane_configuration/index" %}}), [Cloud Cluster Configuration]({{% relref "product/cluster_configuration/index" %}}) and [Virtual Machines Operation]({{% relref "product/virtual_machines_operation/index" %}}). diff --git a/content/software/installation_process/frontend_installation/frontend_install.md b/content/software/installation_process/frontend_installation/frontend_install.md index 5ff227fe7..4cb812c66 100644 --- a/content/software/installation_process/frontend_installation/frontend_install.md +++ b/content/software/installation_process/frontend_installation/frontend_install.md @@ -31,19 +31,27 @@ After installing the database, follow one of the following guides to configure t Not all OpenNebula dependencies are in base distribution repositories. On selected platforms below you need to enable third party repositories by running the following commands under privileged user (`root`): +{{< tabpane text=true right=false >}} +{{% tab header="**OS**:" disabled=true /%}} + +{{% tab header="**AlmaLinux 9, 10**"%}} **AlmaLinux 9, 10** ```shell yum -y install epel-release ``` +{{% /tab %}} +{{% tab header="**RHEL 9**"%}} + **RHEL 9** ```shell rpm -ivh https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm ``` - +{{% /tab %}} +{{< /tabpane >}} ## Step 3. Installing the Software @@ -81,13 +89,20 @@ There are a few differences in package names among distributions. Those with var Install all OpenNebula Front-end components by executing the following commands under a privileged user: -### AlmaLinux / RHEL +{{< tabpane text=true right=false >}} +{{% tab header="**OS**:" disabled=true /%}} + +{{% tab header="**AlmaLinux 9, 10**"%}} +**AlmaLinux / RHEL** ```shell yum -y install opennebula opennebula-fireedge opennebula-gate opennebula-flow ``` -### Debian / Ubuntu +{{% /tab %}} +{{% tab header="**RHEL 9**"%}} + +**Debian / Ubuntu** ```shell apt-get update @@ -95,13 +110,18 @@ apt-get update ```shell apt-get -y install opennebula opennebula-fireedge opennebula-gate opennebula-flow ``` +{{% /tab %}} +{{% tab header="**SLES / openSUSE**"%}} -### SLES / openSUSE +**SLES / openSUSE** ```shell zypper install opennebula opennebula-fireedge opennebula-gate opennebula-flow ``` +{{% /tab %}} +{{< /tabpane >}} + ## Step 4. Enabling MySQL/MariaDB (Optional) You can skip this step if you want to deploy OpenNebula as quickly as possible for evaluation. diff --git a/content/software/release_information/release_notes/platform_notes.md b/content/software/release_information/release_notes/platform_notes.md index 81d538791..5ee8c9dc9 100644 --- a/content/software/release_information/release_notes/platform_notes.md +++ b/content/software/release_information/release_notes/platform_notes.md @@ -119,6 +119,13 @@ For Windows desktops using **Chrome** or **Firefox** you should disable the opti |-------------|-------------| | WHMCS | 8.13.1 | +### Kubernetes + +| K8s Version | Documentation | +|-------------|---------------| +| 1.34.2 | [v1.34](https://v1-34.docs.kubernetes.io/docs/home/) | +| 1.33.7 | [v1.33](https://v1-33.docs.kubernetes.io/docs/home/) | + ## Certified Infrastructure Scale diff --git a/content/solutions/integration_hub/_index.md b/content/solutions/integration_hub/_index.md index e30351c5c..470f33986 100644 --- a/content/solutions/integration_hub/_index.md +++ b/content/solutions/integration_hub/_index.md @@ -2,5 +2,7 @@ title: "Integration Hub" description: "Details about third-party components supported by OpenNebula." weight: 2 +headless: true +toc_hide: true --- diff --git a/content/solutions/integration_hub/application_appliances/_index.md b/content/solutions/integration_hub/application_appliances/_index.md deleted file mode 100644 index f362ec96c..000000000 --- a/content/solutions/integration_hub/application_appliances/_index.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -title: "Application Appliances" -description: "Still under development." -weight: 1 ---- diff --git a/content/solutions/integration_hub/application_appliances/overview.md b/content/solutions/integration_hub/application_appliances/overview.md deleted file mode 100644 index f967a36df..000000000 --- a/content/solutions/integration_hub/application_appliances/overview.md +++ /dev/null @@ -1,4 +0,0 @@ ---- -title: Overview -weight: 1 ----