Self-Adaptation in Micro-Service Architectures with Kubernetes (Sommersemester 2019)

Lecturer: Prof. Dr. Holger Giese (Systemanalyse und Modellierung) , Sona Ghahremani (Systemanalyse und Modellierung) , Joachim Hänsel (Systemanalyse und Modellierung)

General Information

• Weekly Hours: 2
• Credits: 3
• Graded: yes
• Enrolment Deadline: 26.04.2019
• Teaching Form: Seminar
• Enrolment Type: Compulsory Elective Module
• Course Language: German

Programs, Module Groups & Modules

Description

Self-adaptive software has developed the ability to observe the changes at runtime, reason about itself and autonomously evolve accordingly to fulfill its goals and expected requirements. Self-adaptation capabilities are recognized as an effective methodology to manage the increasing complexity and runtime challenges of many modern software systems [Lemos+2013].

Micro-services are a specific service-oriented architecture (SOA) approach [Krafzig+2005] that are independently executable software components collaborating within a service landscape.  Micro-service architecture, is an architectural style that structures an application as a collection of small autonomous services, modeled around a business domain. In micro-service architecture, each service is self-contained and implements a single business capability. In such setting,  each feature of the architecture can be allotted a different micro-service, handling their own data, and performing different functionalities. From all the domains covered by a service landscape, each micro-service is responsible for a single clearly demarcated domain [Newman2015, Wolff2015].

As a software systems grows, the need to scale is inevitable. Container technologies such as Kubernetes [Kubernetes] achieve scalability by favoring decoupled architectures and providing numerous abstractions and APIs that make it easier to build the decoupled micro-service architectures. Kubernetes is an open source orchestrator for deploying containerized applications. There are many reasons why containers and container APIs like Kubernetes are getting raising attention for micro-service orchestration. Improvements on the velocity, scaling, and efficiency as well as abstracting the infrastructure are the major benefits of employing technologies such as Kubernetes.

Containers and Kubernetes can provide the tools to facilitate the reliable and high velocity deployments of new features to a system while keeping the services highly available.  The core concepts in Kubernetes that enable this are immutability, declarative configuration, and online self-healing systems [Rensin 2015] . 

Containers and Kubernetes support building distributed systems that adhere to the principles of immutable infrastructure. With immutable infrastructure, once an artifact is created in the system it does not change via user modifications. Everything in Kubernetes is a declarative configuration object that represents the desired state of the system. It is Kubernetes's job to ensure that the actual state of the world matches this desired state. Kubernetes is also an online, self-healing system. When it receives a desired state configuration, it does not simply take actions to make the current state match the desired
state a single time. It continuously takes actions to ensure that the current state matches the desired state [Hightower+2017] . 

 Goal

In this seminar we are interested to study how the features provided by the container and kubernetes technology can facilitate self-adaptation in micro-service architectures. 
 

Literature

• [Krafzig+2005] Dirk Krafzig, Karl Banke, Diek Slama. Enterprise SOA: Service-Oriented Architecture Best Practices, Prentice Hall, 2005.
• [Newman2015] Sam Newman. Building Microservices. O'Reilly Media, Inc., 1st edition, 2015.
• [Wolff2015] Eberhard Wolff. Microservices: Grundlagen flexibler Softwarearchitekturen. dpunkt, Heidelberg, 2015.
• [ Cheng+2009]  B.H.C. Cheng, H. Giese, P. Inverardi, J. Magee, R. de Lemos, eds.: Software Engineering for Self-Adaptive Systems. Volume 5525 of Lecture Notes in Computer Science. Springer (2009) (http://dx.doi.org/10.1007/978-3-642-02161-9)
• [Lemos+2013]  R. de Lemos, H. Giese, H.A. Müller, M. Shaw, eds.: Software Engineering for Self-Adaptive Systems II. Volume 7475 of Lecture Notes in Computer Science (LNCS). Springer (2013) (http://dx.doi.org/10.1007/978-3-642-35813-5)
• [Kubernetes]  https://kubernetes.io/
• [Rensin 2015]   D. K. Rensin.Kubernetes - Scheduling the Future at Cloud Scale.  1005Gravenstein Highway North Sebastopol, CA 95472, 2015.
• [Hightower+2017]  K.  Hightower,  B.  Burns,  and  J.  Beda.Kubernetes: Up and Running:Dive into the Future of Infrastructure.  O’Reilly Media, 2017
•  

Learning

The course is a seminar, which has an introductory session comprised by an initial short lecture on the proposed focus areas.

After the introductory session on basic concepts and seminar topics, the students will work (preferably in groups) on jointly identified research topics and will be assigned certain literature/techniques on employing Kubernetes for self-adaptation in micro-servic architectures. Finally each group is required to write a report about their findings and have a presentation.

Examination

For the final mark of the seminar participants, the report contributes to the 50% of the mark . The presentation of the findings contributes to the remaining 50% of the final mark. Please note that students are required to participate in the seminar for the first session as well as the presentations of the other students in the form of questions and feedback. 

Dates

After the short lecture, we will identify and agree on the topics for research groups and then there will not be any regular meetings. Individual meeting of the groups with the supervisor(s) will be scheduled to provide intermediate feedback. Presentations will be given on the same day (date to be determined) usually near to the end of the lecture time of the semester.

The first Lecture:  16.04.2019 at 13:30 in room A-2.2.

Zurück