This study aims to examine the effects of transforming a monolithic server system into a microservice architecture, focusing on the increased latency introduced by using a microservice orchestrator. The microservice orchestrator was implemented using an OpenFlow switch controlled by the Beacon and Ryu OpenFlow controllers. These controllers, along with the round robin, random assign and a server-aware load balancing algorithm, were all compared in order to find the combination resulting in the lowest latency and highest achieved server balance in varying network environments. We show that the OpenFlow switch enforces a client-aware load balancing policy and that only the initial request is handled by the controller, effectively reducing the importance of choosing the optimal OpenFlow controller. In addition, the round robin load balancer was preferred when dealing with homogeneous requests, and a server-aware load balancer was required for heterogeneous requests. For most requests, the system would only slow down by a few microseconds using the proposed architecture. However, for 0.001\% of all requests, the slowdown was much more significant, with each of those requests being at least 100 times slower than when using a monolithic server architecture.

Cílem této práce je vytvořit platformu pro sběr a zobrazování metadat o kryptoměnových adresách z veřejného i temného webu. K dosažení tohoto cíle jsem použil technologie zpracování webu napsané v PHP. Komplikace doprovázející automatické zpracování webových stránek byly vyřešeny techonologí Apache Kafka a jejími schopnosti škálování procesů. Modularita platformy byla dosažena pomocí architektury microservices a Docker containerization. Práce umožňuje jedinečný způsob, jak hledat potenciální kriminální aktivity, které se odehrály mimo rámec blockchain, pomocí webové aplikace pro správu platformy a vyhledávání v extrahovaných datech. Vytvořená platforma zjednodušuje přidávání nových, na sobě nezávislých modulů, kde Apache Kafka zprostředkovává komunikaci mezi nimi. Výsledek této práce může být použit pro detekci a prevenci kybernetické kriminality. Uživatelé tohoto systému mohou být orgány činné v trestním řízení nebo ostatní činitelé a uživatelé, zajímající se o reputaci a kreditibilitu kryptoměnových adres.

This thesis is focused on developing software with ITSM integration features. The aim of this work is to design a suitable software architecture for integration applications in a cloud environment. Due to the use of the solution for many customers, emphasis is placed on sustainability and reusability. After wide technology analysis, a web application has been created that is fully configurable to meet a wide range of customer needs. It is decided to use the Node.js environment and the Loopback 4 framework for application development. To ensure lower costs for the operation of cloud resources, compared to competing technologies such as Java. The entire system is deployed in IBM Cloud. The resulting application is put into production by IBM.

In the digital age that we live in today, we are dependent on numerous web applications or services, from dealing with banking, booking air flights, and handling our taxes. We expect these applications and services to support high availability, data loss prevention, and fast response time. Microservices is a design pattern to support faster software change, and it also supports other non-functional attributes such as scalability and high availability. One way to deploy your software as microservices is to use containers and deploy them on a container cluster such as Kubernetes. The public opinion about writing Kubernetes deployment files is that it is complex and repetitive writing. This project aims to see how model-driven development can assist with the creation of the Kubernetes deployment files. To see how model-driven development can assist in the creation of Kubernetes files. The project will implement a domain-specific modeling language for Kubernetes, and the language should be able to model the application's desired states. And by using model transformation, the tool can generate Kubernetes deployable files.

Learning-based testing (LBT) is a relatively new testing paradigm which automatically generates test cases for black-box testing of a system under test (SUT). LBT uses machine learning to model a SUT, and combines this with model-based testing. This thesis uses LBTest, a research tool created at CSC, in order to apply LBT on a new architectural style of distributed systems called microservices. Two new approaches to using LBT have been implemented to test a commercial product for counter-party credit risk. One approach is to monitor the internal processes to extract the states of the software. The second is based on fault injection on the software level. Errors have been found during the fault injection approach. Lastly, some general recommendations are given on how to implement LBT. / Inlärningsbaserad testning (LBT) är en relativt ny testningsparadigm som automatiskt genererar testfall för black-box-testning av ett system under test (SUT). LBT använder sig av maskininlärning för att modellera ett SUT, och kombinerar det med modellbaserad testning. I det här examensarbetet används LBTest, ett forskningverktyg skapat på CSC, för att applicera LBT på microservices. Två nya tillvägagångssätt att använda LBT på har implementerats för att testa en kommersiell produkt för uträkning av kreditrisk hos motparter. Ett tillvägagångssätt är att avlyssna interna processer för att extrahera tillstånden hos mjukvaran. Det andra tillvägagångssättet är baserat på felinjicering på mjukvarunivå. Fel har hittats med hjälp av felinjiceringstillvägagångssättet. Som avslutning ges rekommendationer till hur LBT implementeras.

Denna studie ämnar att bidra till kunskap till skapandet av en regelmotor för hanteringen av verksamhetsregler ur ett systemutvecklarperspektiv. Studien har utförts hos företaget Mobilaris som själva har identiferat ett potentiellt behov av verktyg för att på bättre sätt hantera verksamhetsregler. Innan studien påbörjades, så utfördes en förstudie då regelmotor som skulle nyttjas valdes ut. Studien har genom en designstudie där en regelmotor iterativt har utvecklats för att passa systemet Planning & Scheduling™. Datainsamlingen är gjort genom enkäter och semistrukturerade intervjuer som föregåtts av en presentation av artefakten. Enkäterna har följt en kvantitativ modell som kallas System Usability Scale. De semistrukturerade intervjuerna har sedan analyserats med hjälp av en innehållsanalys för att kunna identifera behoven och göra artefakten bättre. Resultatet av studien är riktlinjer som med fördel kan användas när man implementerar en regelmotor för ett resursplanneringssystem. Studien har identiferat nio teoretiska koncept varav åtta har kunnat bekräftas utifrån empirin. Det har också identiferats fyra nya designprinciper som anses göra regelmotorn bättre. / This study aims to contribute knowledge to the creation of a rule engine for the management of business rules from a system developer perspective. The study was conducted at a company called Mobilaris, which has identifed a potential need for tool to better manage business rules in one of their systems. Before the study began, a pilot study was carried out to select the rule engine that where going to be used in the study. The study has through a design science study where a rule engine has iteratively developed to fit the system Planning & Scheduling™. The data collection is done through surveys and semi-structured interviews that are preceded by a presentation of the artifact. The surveys follow a model called the System Usability Scale. The semi-structured interviews was then analyzed using a content analysis to be able to identify needs to make the artifact better. The results of the studies are guidelines that can be benefcial when implementing a rule engine for a resource planning system. The study has identifed nine theoretical concepts, of which eight have been confrmed based on empirical evidence. Four new design principles have also been identifed that are considered to make the rule engine better.

In recent years, microservice architecture has surpassed monolithic architecture in popularity among developers by providing a flexible way of developing complex distributed applications. Whereas a monolithic application functions as a single indivisible unit, a microservices-based application comprises a collection of loosely coupled services that communicate with each other to fulfill the requirements of the application. Consequently, different services in a microservices-based application can be developed and deployed independently. However, this flexibility is achieved at the expense of reduced observability of microservices-based applications complicating the debugging of such applications. The reduction of observability can be compensated by performing distributed tracing in microservices-based applications. Distributed tracing refers to observing requests propagating through a distributed system to collect observability data that can aid in understanding the interactions among the services and pinpoint failures and performance issues in the system. Open- Telemetry, an open-source observability framework supported by Cloud Native Computing Foundation (CNCF), defines a standardized specification for generating observability data. Nevertheless, instrumenting an application with an observability framework incurs performance overhead. To tackle this deterioration of performance and to reduce the cost of persisting observability data, only a subset of the requests are typically traced by performing head-based or tail-based sampling. In this work, we present a tail-based sampling framework using stream processing techniques. The developed framework demonstrated promising performance in our experiments by saving approximately a third of memory-based storage compared to an OpenTelemetry tail-based sampling module. Moreover, being compliant with the OpenTelemetry specifications, our framework aligns well with the OpenTelemetry ecosystem. / Under de senaste åren har mikrotjänstarkitektur överträffat monolitisk arkitektur i popularitet bland utvecklare genom att erbjuda ett flexibelt sätt att utveckla komplexa distribuerade tillämpningar. Medan en monolitisk tillämpning fungerar som en enda odelbar enhet, består en mikrotjänstbaserad tillämpning av en samling löst kopplade tjänster som kommunicerar med varandra för att uppfylla tillämpningens krav. Därför kan olika tjänster i en mikrotjänstbaserad tillämpning utvecklas och driftsättas oberoende av varandra. Denna flexibilitet uppnås dock på bekostnad av minskad observerbarhet för mikrotjänstbaserade tillämpningar, vilket försvårar felsökningen av sådana tillämpningar. Den minskade observerbarheten kan kompenseras genom att utföra distribuerad spårning i mikrotjänstbaserade tillämpningar. Distribuerad spårning innebär att man observerar förfrågningar som sprids genom ett distribuerat system för att samla in data om observerbarhet som kan hjälpa till att förstå interaktionerna mellan tjänsterna och lokalisera fel och prestandaproblem i systemet. OpenTelemetry, ett ramverk för observerbarhet med öppen källkod som stöds av Cloud Native Computing Foundation (CNCF), definierar en standardiserad specifikation för att generera observerbarhetsdata. Att instrumentera en tillämpning med ett ramverk för observerbarhet medför dock en överbelastning av prestanda. För att hantera denna försämring av prestanda och för att minska kostnaden för att bevara observerbarhetsdata spåras vanligtvis endast en delmängd av förfrågningarna genom att utföra s.k. “head-based sampling” eller “tail-based sampling”. I det här arbetet presenterar vi ett ramverk för tail-based sampling med hjälp av strömbehandlingsteknik. Den utvecklade ramen visade lovande prestanda i våra experiment genom att spara ungefär en tredjedel av den minnesbaserade lagringen jämfört med en OpenTelemetry-modul för tail-based sampling. Eftersom vårt ramverk är förenligt med OpenTelemetry-specifikationerna är det dessutom väl anpassat till OpenTelemetry-ekosystemet.

Context. Cloud computing is growing fast and has established itself as the next generationsoftware infrastructure. A major role in cloud computing is the virtualization of hardware toisolate systems from each other. This virtualization is often done with Virtual Machines thatemulate both hardware and software, which in turn makes the process isolation expensive. Newtechniques, known as Microservices or containers, has been developed to deal with the overhead.The infrastructure is conjoint with storing, processing and serving vast and unstructureddata sets. The overall cloud system needs to have high performance while providing scalabilityand easy deployment. Microservices can be introduced for all kinds of applications in a cloudcomputing network, and be a better fit for certain products.Objectives. In this study we investigate how a small system consisting of a Cassandra clusterperform while encapsulated in LXC and Docker containers, compared to a non virtualizedstructure. A specific loader is built to stress the cluster to find the limits of the containers.Methods. We constructed an experiment on a three node Cassandra cluster. Test data is sentfrom the Cassandra-loader from another server in the network. The Cassandra processes are thendeployed in the different architectures and tested. During these tests the metrics CPU, disk I/O,network I/O are monitored on the four servers. The data from the metrics is used in statisticalanalysis to find significant deviations.Results. Three experiments are being conducted and monitored. The Cluster test pointed outthat isolated Docker container indicate major latency during disk reads. A local stress test furtherconfirmed those results. The step-wise test in turn, implied that disk read latencies happened dueto isolated Docker containers needs to read more data to handle these requests. All Microservicesprovide some overheads, but fall behind the most for read requests.Conclusions. The results in this study show that virtualization of Cassandra nodes in a clusterbring latency in comparison to a non virtualized solution for write operations. However, thoselatencies can be neglected if scalability in a system is the main focus. For read operationsall microservices had reduced performance and isolated Docker containers brought out thehighest overhead. This is due to the file system used in those containers, which makes disk I/Oslower compared to the other structures. If a Cassandra cluster is to be launched in a containerenvironment we recommend a Docker container with mounted disks to bypass Dockers filesystem or a LXC solution.

"Microservices" has become a real buzz word in the software development community during the last couple of years. Most developers are familiar with the architectural concept which solves the problem of systems growing to large monoliths too complex to handle. This architecture has however mostly been used in backend development, even though many companies are struggling with large, monolithic frontend codebases. This is where micro frontends come in, an architectural as well as organisational approach to developing applications all the way from presentation to data layer. The micro frontends approach is relatively new, and even though there is some talk about it in the software community, many companies are unfamiliar with it, and there is very limited scientific work performed on the topic. The aim of this study was to investigate strengths of and challenges with micro frontends, and specifically how the modifiability of a web application is affected by developing it as a micro frontends project. The method for fulfilling the aim consisted of several parts. During one part, two frontend prototypes of a web application were implemented, one using a Single Page Application technique and one using a micro frontends technique. Another part consisted of interviewing practitioners in the software field with relevant backgrounds to gain their perspective on micro frontends. The results were also used to evaluate which prototype would be most suitable for the specific web application. During the last part of the method, measurements on the implemented prototypes were performed to be used to estimate the modifiability of the prototypes using a mathematical model of modifiability called SQMMA. Based on the results, this report provides an extensive summary of strengths of micro frontends, among other things that there are both beneficial and disadvantageous aspects of micro frontends when it comes to modifiability, risks that should be considered when adopting micro frontends, and a discussion on when to use it and not.

Context The last decade shows many solution proposals of functional decomposition techniques to aid in developing microservice architectures. While some solutions may work, it is uncertain what the effects are on quantitative, measurable metrics; thus, the proposals require validation. Objective The study measures the effects of various functional decomposition techniques on performance, scalability, and maintainability. Furthermore, the study will compare the treatments in order to find whether a statistical significance exists. Method The study uses a controlled experiment containing three functional decomposition techniques—Event Storming, Actor/Action, and Service Cutter—applied on the same use case. The use case follows the CoCoMe framework, which forms the basis of the experiment. Results Each treatment shows similar behavior while presenting different architectural designs. The study found no statistical significance for performance, scalability, and maintainability. Conclusion Evidence suggests that the convenience of an approach might be more important than the resulting architecture since they will likely lead to the same outcome. If performance issues arise, it would likely be due to the microservices architecture and not the functional decomposition technique; therefore, the microservices architecture might not equally benefit any situation or corporation. Furthermore, the study found that service granularity might not be as relevant as some studies claim it to be, and other factors could be more crucial.