The implementation of Container as a Service (CaaS) cloud using openSUSE kubic

Currently, software development based on Development and Operations (DevOps) generally uses containers and Cloud Computing to support portability, reliability, scalability, and security. One combination of these two technologies is Container as a Service (CaaS) Cloud. From a number of previous researches, no one has studied the technical implementation and deployment of CaaS using openSUSE Kubic based on the Linux kernel and Linux operating system, as well as testing in it using Pods from the service and replication side. The test results prove that openSUSE Kubic is very easy and reliable to use for CaaS implementation and deployment, so it is very helpful for software developers in realizing software development more scalable and faster.


Introduction
Currently, software development uses the Development and Operations (DevOps) methodology and approach, which emphasizes the process of communication, collaboration, and integration between software developers and IT professionals [1]. By using DevOps, it allows for good cooperation between the development department and the operational division, thereby reducing development costs and time and increasing performance [2]. The cost of releasing software also decreased due to software as a service, where organizations can release software early and with a high frequency, so that they have a higher capability to compete in the market.
To realize software as a service, Cloud Computing is implemented to complement DevOps. Cloud Computing is a computing model that provides convenience, comfort, and on-demand access to access and configure computing resources (network, servers, storage, applications, and services) that can be quickly released without much interaction with providers. Service [3,4]. Software as a Service Cloud is one of three types of services provided by Cloud Computing to users according to their needs, where the other two services are Platform as a Service Cloud and Infrastructure as a Service Cloud [5].
Regarding DevOps in software development, the need for compatibility and portability in different software environments makes a container used in it. In the context of the Linux environment commonly used in software development, a container is a tool in the form of software that runs at the operating system level (especially on the Linux operating system), which can be used to create an isolated system, which can run on a single kernel-based host. Linux [6,7]. Compared to a Virtual Machine (VM), a Container has advantages in terms of flexibility, scalability, resource savings in IT Management, and shortens software development and testing times on various platforms [8]. Two opensource containers that are widely used today in DevOps are Docker and Kubernetes [9,10,11].
There has been several of previous researches covering containers, Container as a Service (CaaS) Cloud, docker, and Kubernetes on DevOps. Literature study regarding container security and solutions is discussed by [12], using four use cases, namely: protecting a container from applications inside it, inter-container protection, protecting the host from containers, and protecting containers from a malicious host. The results of this research are container security requirements and possible vulnerabilities and attacks. The research about Container as a Service (CaaS) has been conducted by [13] to shows a novel architecture for task selection and scheduling at the edge of the network using Container as a Service (CaaS) at Nano Data Center at Fog Computing, with the results shown that the proposed scheme reduces the energy consumption. Research about Container as a Service (CaaS) also conducted by [14] with the purpose to improve resource utilization of CPU cores, memory size of both VMs and PMs, and minimize the number of instantiated VMs and active PMs in a cloud environment, using Best Fit (BF) and Max Fit (MF) method.
The implementation of Docker to make it easier for computer users to use the application without the need for configuration along with data transfer speed testing on the LVM and RAID used in it, has been carried out by [15] with a case study at the Department of Information Engineering of Petra Christian University. The test results show that the implementation of Docker can make it easier for users to use the computer without the need for further configuration, as well as better data transfer speeds in RAID compared to LVM. Other research on docker to support queries related to performance monitoring and logging services for a single container, performance monitoring, and log service schemes on a distributed platform, was carried out by [16] accompanied by technical and analysis. The results of this study were in the form of significance of guidelines for integration and perfection of Docker-based services.
Research on Kubernetes on microservice was conducted by [17] using the Availability Management Framework (AMF) as a solution for middleware services to handle high-availability for some applications. The results of this research shown that the service outage for some of the applications managed with Kubernetes is significantly high. Another research on Kubernetes was carried out by [18] through a proposed algorithm from the results of studying the scheduling-modules in the K8s source code, to reduce the total resource cost and the maximum load of the node, and makes the task assignment more balanced on Kubernetes. The results of this study can show that the proposed algorithm is better than the original scheduling algorithm in terms of handling load balanced on Kubernetes.
From these previous researches, there has been no specific discussion regarding the technicalities of creating a Container as a Service (CaaS) Cloud using both Linux kernel and Linux operating system. For this reason, this research raises the technical implementation and deployment of CaaS using openSUSE Kubic. OpenSUSE Kubic is a project from openSUSE that is based on Linux kernel and Linux operating system (especially openSUSE Tumbleweed), devoted to implementing containers and handling microservices [19].
In this research, two points form the problem in the form of research questions, namely: 1.) How to implement and deploy Container as a Service (CaaS) using openSUSE Kubic? 2.) How to do test the implemented and deployed CaaS using Pods?
The purpose of this research is to prove the ease of implementation and deployment of Container as a Service (CaaS) based on openSUSE Kubic along with testing in it using Pods, so that it can help software developers with the DevOps method in developing and testing software better and faster based on containers.

Material and methods
To support the implementation and testing of this research, several supporting hardware and software were used. The hardware used is a Dell Latitude E6440 Notebook (Intel Core i7, 16GB RAM, 500GB hard drive), internet modem, and mouse. The software used is the openSUSE Kubic (MicroOS) 64 bit with Docker, Kubernetes, and Pod inside it. The research was conducted in the period from the beginning of May 2020 to mid of December 2020 by online during the Covid19 pandemic.
This research uses a methodology in the form of a Systematic Literature Review (SLR) [20] utilizing some references from various published papers, books, and website URLs on the internet, related to containers, dockers, Kubernetes, Container as a Service, along with several related studies that have been done previously. as a state of the art.
In this study, assessment indicators are used, namely: 1.) The ability of openSUSE Kubic to assist the implementation and deployment process of Container as a Service (CaaS) through the available modules, where every step of implementation and testing is observed and recorded, and 2.) Testing the implementation and deployment of CaaS based on openSUSE Kubic using Pods available in it to test service and replication processes. In this study, observations were made, saved screenshots, recorded, analyzed, and discussed the test results, to be evaluated and obtained conclusions that answered the research questions. To support the implementation, deployment, and testing carried out in this study, the openSUSE Linux online repository is used. The openSUSE online repository is a digital repository for storing thousands of additional applications and libraries that can be quickly and easily added to the online operating system if required by the user, providing by SUSE [21] and replicated locally in Indonesia (mirror) [22].
The implementation and testing steps in this research were carried out based on the design of the test scenario and the research flowchart. The test scenario involves a computer to then install and configure openSUSE Kubic to implement, deploy, and testing Container as a Service (CaaS) utilizing Pods. The computer also including with Kubernetes, Docker, and Pods inside it. While the research flowchart describes the sequence of steps and processes carried out during this research. The testing scenario and research flowchart are shown in Figure 1 and Figure 2, respectively:

Installing openSUSE Kubic with Administration and Repository Setting
The first step is to install openSUSE Kubic on the computer. Installation using the OpenSUSE MicroOS .iso file according to the instructions on the screen, choosing a system role in the form of Kubeadm Node with the kubeadm init command, configuring the root password, and configuring the online repository. In this research, the system role is using kubeadm Node, as shown in Figure 3 below:

Implementation
After installation, the login process is carried out as root into the system. Then the master cluster is created using the kubeadm init command. After the cluster is formed and initialized, the kubeadm join command is executed so that workers can be merged into the cluster with the token, as shown in Figure 4 below: Figure 4 Merger the Worker into the Cluster After the workers are merged into the cluster, a kubeconfig directory is created in Kubernetes, located at $HOME/.kube/config using the mkdir command. Then the admin.conf file is copied from /etc/ kubernetes/ into the $HOME/.kube/config directory using the cp -i command, ending by changing the ownership of the $HOME/.kube/config directory to root. This process shown at Figure 5 below: Figure 5 Create kubeconfig directory and copy the files The final step of implementation is to checking the node status using the kubectl get nodes command. The output displayed is that there is one node connected to the cluster, namely localhost with the master roles. Then do the master node configuration on a single node using the command kubectl taint nodes --all node.role.kubernetes.io/masternode/localhost untainted to remove restrictions from pods running on the master node (in this research it is a single node). The process of checking the node status and master node configuration, shown at Figure 6 and Figure 7, respectively:

Deployment
After the initial implementation of Container as a Service (CaaS) using openSUSE Kubic was successfully carried out, then continued with the deployment stage. For the deployment of this research, the hello-kubic.yaml [23] file is used. The hello-kubic.yaml file is located in /usr/share/k8s-yaml/hello-kubic and is used as a Pod.
The Hello-kubic Pod is configured to perform 3 replications, which are managed via the replicas: 3 line in hellokubic.yaml. The contents of the hello-kubic.yaml file are as follows: The deployment process uses hello-kubic was done using the command kubectl apply -f /usr/share/k8s-yaml/hellokubic/hello-kubic.yaml as shown in Figure 8 below:

Figure 8 Deployment Process
After the deployment using hello-kubic is complete, then checking the Pod status again using the kubectl get deployment command. From the inspection using kubectl get pods command, it was found that the hello-kubic Pod made three replicates successfully, where all three replicates were available, ready, and running. The process of checking the Pod status after deployment using hello-kubic and all of three replicates were available and running, shown in Figure 9 and Figure 10 below, respectively: Finally, checking the services running on CaaS that have been implemented and deployed. Checks running services using the kubectl get svc command. Figure 11 below shown the output of this command: Figure 11 Checking the Service Running

Results and discussion
Containers are basically an extension of virtualization using the concept where services and resources run isolated in different libraries, drivers, and binaries, through resource sharing on the operating system. Thus, the containers can run on the same machine and can share the operating system kernel, because each container runs as an isolated process. Containers isolate only libraries to run so they can be more effective and lightweight when running. From the Container concept, Container as a Service (CaaS) runs as a container-based service in the Cloud Computing network that summarizes all running services. This makes software development faster, scalable, secure, efficient, and supports high portability.
From the output shown in Figure 11, it can be observed and discussed that there are two running services, namely kubernetes service and hello-kubic service. The first service is hello-kubic service. This service is Load Balancer type, with CLUSTER-IP address of 10.107.154.186 and runs on port number 80 and port node number 31656. It is running on Network Layer using Transmission Control Protocol (TCP). The second service is kubernetes service. It has a ClusterIP type with a ClusterIP address 10.96.0.1 and runs on port 443. Same as the first service, kubernetes service also running on Network Layer using Transmission Control Protocol (TCP). With the concept of container and Container as a Service (CaaS), the running of two services indicates that CaaS deployment using openSUSE Kubic has been successfully implemented.

Conclusion
From the testing that has been done, it can be concluded that openSUSE Kubic can be relied on to implement and deploy Container as a Service (CaaS) quickly and easily in handling several services and applications in the form of containers, with Kubernetes and Pod support. Based on openSUSE Tumbleweed and open-source Linux kernel, this makes it easier for software developers and organizations to implement and deploy CaaS as needed.