C_KYMD_01 SAP Certified Development Associate - Side-by-Side Extensibility based on SAP BTP Kyma runtime Questions and Answers

Kubernetes pods are the smallest deployable units of computing that you can create and manage in Kubernetes. A pod is a group of one or more containers, with shared storage and network resources, and a specification for how to run the containers. Pods are the atomic unit on the Kubernetes platform. Pods are not permanent units in Kubernetes. They can be terminated and replaced anytime, either by the user or by the system. Pods are ephemeral and disposable entities that are created and destroyed dynamically. Pods can be scaled up or down, migrated across nodes, or rescheduled due to failures or maintenance. Pods cannot contain deployments. Deployments are higher-level resources that manage pods and provide declarative updates to them. A deployment can create multiple pods from the same template and ensure that the desired number of pods are always available. A pod can only contain containers and volumes, not other Kubernetes resources. References: Pods | Kubernetes, Viewing Pods and Nodes | Kubernetes, What is a Kubernetes pod? - Red Hat, What are Pods in Kubernetes? - Medium, Network overview | Google Kubernetes Engine (GKE) | Google Cloud.

Namespaces are used to isolate groups of resources in a Kubernetes cluster1. Namespaces provide a logical scope for resources, such as pods, services, deployments, and secrets. Namespaces can be used to separate different environments, teams, projects, or applications within the same cluster. Namespaces also enable resource quota management, access control, and service discovery within the cluster2. Namespaces are not the same as organizations and spaces, which are concepts used in Cloud Foundry to manage applications and services3. Semantic versioning is a convention for assigning version numbers to software releases, not a method for isolating resources. Object groups are not a native Kubernetes concept, but a term used in some tools or frameworks to group related resources. References: 1(https://learn.microsoft.com/en-us/azure/aks/operator-best-practices-cluster-isolation),  2(https://stackoverflow.com/questions/68314160/kubernetes-how-best-to-isolate-resources-based-on-environment-labels-and-sele),  3(https://packetpushers.net/4-methods-of-kubernetes-isolation/), ,

 A one off/non parallel job is a workload type that runs a single task to completion and then terminates. This is suitable for running a database migration on SAP BTP, Kyma runtime, as it does not require scaling, persistence, or parallelism. A parallel job, on the other hand, is a workload type that runs multiple tasks in parallel and then terminates. This is useful for batch processing or data analysis, but not for database migration. A StatefulSet is a workload type that runs one or more pods that maintain a stable identity and persistent storage. This is useful for stateful applications such as databases or message brokers, but not for database migration. A DaemonSet is a workload type that runs one pod on each node in the cluster. This is useful for providing node-level services such as logging or monitoring, but not for database migration. References: Workload Concepts, Kubernetes Workloads

Stateless workloads are workloads that do not store any data or application state on the host that serves the requests. Instead, they rely on the information provided by the client or an external service, such as a database, to process each request independently. Stateless workloads do not keep any references to past transactions or interactions, and they can be handled by any available server. Stateless workloads are more scalable, fault-tolerant, and easier to manage than stateful workloads, which require persistent storage and session management. Some examples of stateless workloads are web servers, print servers, or microservices. References: Stateful vs stateless - Red Hat, Create stateless workloads | Google Distributed Cloud Hosted - Google Cloud, Stateless vs Stateful Kubernetes - WEKA

 Grafana and Prometheus Web UI are the open-source projects that provide data visualization in the kyma-system Namespace. Grafana is a visualization and analysis tool that can create dashboards from various data sources, such as Prometheus and Loki. Prometheus Web UI is a web interface that allows users to query and visualize the metrics collected by Prometheus. Both Grafana and Prometheus Web UI can be accessed from the Kyma Dashboard by selecting the namespace kyma-system and choosing the menu option Configuration -> Tools. References: Describing Observability in Kyma, Accessing the built-in observability tools of Kyma runtime, Using the Kyma Dashboard

 Kubernetes pods are the smallest and most basic unit of an application in Kubernetes. They are ephemeral and can be created and destroyed at any time. Pods managed by deployments are not meant to be accessed directly, but rather through services that provide load balancing and service discovery. To ensure that pods managed by deployments are unique and identifiable, they are assigned a random hash suffix as part oftheir name. For example, a pod named nginx-deployment-6dd86d77d-ztqvs belongs to a deployment named nginx-deployment and has a hash suffix of 6dd86d77d-ztqvs12. References: Deployments | Kubernetes, Kubernetes Administrator: Managing Pods & Deployments

To pull a container image from a private registry, you need to create a secret with the type “kubernetes.io/dockerconfigjson” and provide the credentials in the pod manifest via “imagePullSecrets” in spec.template.spec. This way, the kubelet can use the secret to authenticate with the private registry and pull the image. The secret type “Opaque” is not suitable for this purpose, as it is a generic type that can store any data. The pod manifest does not support providing credentials via “imagePullSecrets” in spec.template.metadata.annotations, as this is not a valid field. References: Side-by-Side Extensibility Based on SAP BTP, Kyma Runtime - Unit 3 - Lesson 2: Using Secrets, [Kubernetes Documentation - Pull an Image from a Private Registry]

 A service mesh in Kyma typically consists of two components: the data plane and the control plane12. The data plane is responsible for handling the communication between the microservices in the cluster. It consists of a set of sidecar proxies (Envoy) that are injected into each pod and intercept the traffic. The control plane is responsible for managing the configuration and policies of the data plane. It consists of a set of components (Istio) that provide features like service discovery, security, traffic management, observability, and more12. References: Discovering the Service Mesh, SAP BTP – KYMA – SERVICE MESH | SAP Blogs

Pods are created in a sequential order when a StatefulSet is set up. This means that for a StatefulSet with N replicas, the Pods are deployed one by one, starting from the Pod with the index 0 and ending with the Pod with the index N-1. Each Pod has to be in the Running and Ready state before the next Pod is created. This ensures that the Pods have a predictable and unique identity and can be connected to their corresponding persistent volumes. References: https://www.howtoforge.com/create-a-statefulset-in-kubernetes/

https://kubernetes.io/docs/tutorials/stateful-application/basic-stateful-set/

 The Kyma Eventing process uses the following technologies:

• HTTP-post requests: HTTP requests are delivered via POST-requests in terms of sending and receiving the events1.
• Jet Stream: Jet Stream provides the back end for the Kyma Eventing process1.
• NATS: NATS is an open source messaging system that is used for the Kyma Eventing process12. References: Discovering Kyma Eventing - SAP Learning, In-cluster eventing in SAP BTP, Kyma runtime | SAP Blogs

The command kubectl get services lists all the services in the current namespace1. The get command is used to display one or more resources in Kubernetes2. The services argument specifies the type of resource to list. To list services in a differentnamespace, you can use the --namespace or -n flag3. References: Kubectl commands to list services, deployments and pods from namespace …, kubectl Cheat Sheet | Kubernetes, How to get the current namespace of current context using kubectl - Stack Overflow

 A CronJob is a workload type that creates Jobs on a repeating schedule, based on the Cron syntax. A Job is a workload type that runs a task to completion, just once. A Deployment is a workload type that manages a set of Pods that are created from the same template. A StatefulSet is a workload type that manages a set of Pods that have stable identities and persistent storage. References: CronJob, Jobs, Workloads.

The kube-scheduler is a control plane process that assigns pods to nodes based on scheduling principles, such as resource requirements, affinity, anti-affinity, and more. The kube-scheduler watches for newly created pods that have no node assigned and selects an optimal node for each pod to run on. The kube-scheduler does not start pods, scale nodes, or schedule Cron Jobs. These are the responsibilities of other components, such as the kubelet, the cluster autoscaler, and the kube-controller-manager. References: Kubernetes Scheduler, kube-scheduler

The SAP BTP service operator on SAP BTP, Kyma runtime uses the SAP Service Manager to consume services on SAP BTP. The SAP Service Manager is a component that provides a unified way of provisioning, accessing, and managing services from different providers and platforms. The SAP Service Manager implements the Open Service Broker API (OSB API) to communicate with service brokers and expose their services to applications. The SAP BTP service operator on SAP BTP, Kyma runtime leverages the SAP Service Manager to create and manage service instances and bindings for SAP BTP services in the Kyma cluster. The SAP BTP service operator also synchronizes the service catalog from the SAP Service Manager to the Kyma Service Catalog, so that users can discover and consume SAP BTP services through the Kyma Console or the Kubernetes API. References: https://learning.sap.com/learning-journey/deliver-side-by-side-extensibility-based-on-sap-btp-kyma-runtime/defining-sap-btp-service-management-in-the-kyma-environment_a2d02cae-3e38-4297-83e6-8f388f609889

https://blogs.sap.com/2022/07/12/the-new-way-to-consume-service-bindings-on-kyma-runtime/

A Kubernetes cluster consists of two types of components: the control plane and the worker nodes. The control plane is responsible for managing the cluster state and orchestrating the containerized applications. The worker nodes are the machines that run the applications in pods. Some of the components of the architecture of a Kubernetes cluster are:

• kubelet: The kubelet is an agent that runs on each worker node and communicates with the control plane. The kubelet ensures that the pods and containers are running as expected, and reports the node status and resource usage to the control plane1.
• kube-proxy: The kube-proxy is a network proxy that runs on each worker node and enables the service abstraction. The kube-proxy maintains the network rules on the nodes, and allows the pods to communicate with each other and with external services2.
• etcd: The etcd is a distributed key-value store that stores the cluster configuration and state. The etcd is the source of truth for the cluster, and is accessed by the control plane components. The etcd is designed to be consistent, reliable, and secure3.

References:

• 1: Kubernetes Components | Kubernetes
• 2: Services, Load Balancing, and Networking | Kubernetes
• 3: etcd | Kubernetes