Serverless edge computing is a distributed network and computing system in which the data is processed at the edge of the network based on serverless architecture. It can provide large-scale computing and storage resources with low latency, which are very useful in AI applications such as object detection. However, when analyzing serverless computing architectures, we model them using simple models, such as single server or multi-server queues, and it is important to make sure these models can explain the behaviors of real systems. Therefore, we focus on the performance evaluation of serverless edge computing for AI applications in this project. With that, we aim at proposing more realistic and accurate models for real serverless architectures. In this project, our objective is to evaluate the performance and model mathematically an object-detection application running on a serverless architecture implemented with Kubernetes. This project provides a detailed description of the implementation of the serverless platform and YOLOv5-based object detection application. After implementation, we design experiments and make performance evaluations of the time of object detection results and quality of object detection results. Finally, we conclude that the number of users in the system significantly affects the service time. We observe that there is no queue in the system, so we cannot just use mathematical models with a queue to model the system. Therefore, we consider that the processor sharing model is more appropriate for modeling this serverless architecture. This is very helpful for giving insights on how to make more realistic and accurate mathematical queueing models for serverless architectures. For future work, other researchers can also implement our serverless platform and do further development, such as deploying other serverless applications on it and making performance evaluations. They can also design other use-cases for the experiments and make further analyses on queue modeling of serverless architecture based on this project. / Serverless edge computing är ett distribuerat nätverk och datorsystem där data bearbetas i kanten av nätverket baserat på serverlös arkitektur. Det kan tillhandahålla storskaliga dator- och lagringsresurser med låg latens, vilket är mycket användbart i AI-applikationer som objektdetektering. Men när vi analyserar serverlösa datorarkitekturer modellerar vi dem med hjälp av enkla modeller, till exempel enstaka servrar eller köer med flera servrar, och det är viktigt att se till att dessa modeller kan förklara beteendet hos verkliga system. Därför fokuserar vi på prestandautvärdering av serverlös edge computing för AI-applikationer i detta projekt. Med det siktar vi på att föreslå mer realistiska och exakta modeller för riktiga serverlösa arkitekturer. I detta projekt är vårt mål att utvärdera prestandan och matematiskt modellera en objektdetekteringsapplikation som körs på en serverlös arkitektur implementerad med Kubernetes. Detta projekt ger en detaljerad beskrivning av implementeringen av den serverlösa plattformen och den YOLOv5-baserade objektdetekteringsapplikationen. Efter implementering designar vi experiment och gör prestandautvärderingar av tidpunkten för objektdetekteringsresultat och kvaliteten på objektdetekteringsresultaten. Slutligen drar vi slutsatsen att antalet användare i systemet avsevärt påverkar servicetiden. Vi observerar att det inte finns någon kö i systemet, så vi kan inte bara använda matematiska modeller med en kö för att modellera systemet. Därför anser vi att processordelningsmodellen är mer lämplig för att modellera denna serverlösa arkitektur. Detta är mycket användbart för att ge insikter om hur man gör mer realistiska och exakta matematiska kömodeller för serverlösa arkitekturer. För framtida arbete kan andra forskare också implementera vår serverlösa plattform och göra vidareutveckling, såsom att distribuera andra serverlösa applikationer på den och göra prestandautvärderingar. De kan även designa andra användningsfall för experimenten och göra ytterligare analyser av kömodellering av serverlös arkitektur utifrån detta projekt.

Цель работы – разработка серверной части приложения и инфраструктурных компонентов для проекта «Мониторинг IT-конференций». Методы исследования: анализ, сравнение, систематизацию и обобщение данных о существующих и разработанных инфраструктурных компонентах, апробация современных подходов при построении архитектуры инфраструктуры. В результате работы сконфигурированы две виртуальные машины для работы Kubernetes и Gitlab Runner, настроены компоненты хранения постоянных данных для PostgreSQL, RabbitMQ и S3-хранилища на базе Rook Ceph, создано приложение на базе Django для предоставления API клиентскому приложению, написана конфигурация для Gitlab CI, обеспечивающая сборку образа приложения и его развертывание в Kubernetes. Созданное приложение предоставляет функционал управления контентом для администраторов сервиса (загрузка видео в S3-хранилище, разметка с помощью системы тегов, привязывание конференций к спикерам) и HTTP API для клиентского приложения с возможностью регистрации, аутентификации через JWT-токены, иерархическому поиску по системе тегов и отдаче подписанных ссылок на S3-хранилище для просмотра видео. / The purpose of the work is to develop the server part of the application and infrastructure components for the project "Monitoring IT conferences". Research methods: analysis, comparison, systematization and generalization of data on existing and developed infrastructure components, approbation of modern approaches in building infrastructure architecture. As a result of the work, two virtual machines were configured for Kubernetes and Gitlab Runner, persistent data storage components for PostgreSQL, RabbitMQ and S3 storage based on Rook Ceph were configured, an application based on Django was created to provide an API to a client application, a configuration for Gitlab CI was written, providing building an application image and deploying it to Kubernetes. The created application provides content management functionality for service administrators (uploading videos to S3 storage, marking using a tag system, binding conferences to speakers) and an HTTP API for a client application with the ability to register, authenticate through JWT tokens, hierarchical search using the tag system, and giving back signed links to S3 storage for watching videos.

This thesis focuses on addressing the challenges of resource management in cloud environments, specifically in the context of running resource-optimized applications on Kubernetes. The scale and growth of cloud services, coupled with the dynamic nature of workloads, make it difficult to efficiently manage resources and control costs. The objective of this thesis is to explore the proactive autoscaling of virtual resources based on traffic demand, aiming to improve the current reactive approach, the Horizontal Pod Autoscaler (HPA), that relies on predefined rules and threshold values. By enabling proactive autoscaling, resource allocation can be optimized proactively, leading to improved resource utilization and cost savings. The aim is to strike a balance between resource utilization and the risk of Service Level Agreement (SLA) violations while optimizing resource usage for microservices. The study involves generating predictions and assessing resource utilization for both the current HPA implementation and the proposed solution. By comparing resource utilization and cost implications, the economic feasibility and benefits of adopting the new approach can be determined. The analysis aims to provide valuable insights into resource utilization patterns and optimization opportunities. The analysis shows significant improvements in CPU utilization and resource consumption using the proposed approach compared to the current HPA implementation. The proactive strategy allows for handling the same number of requests with fewer replicas, resulting in improved efficiency. The proposed solution has the potential to be applied to any type of service running on Kubernetes, with low computational costs. In conclusion, the analysis demonstrates the potential for resource optimization and cost savings through the proposed approach. By adopting proactive strategies and accurately predicting resource needs, organizations can achieve efficient resource utilization, system robustness, and compliance with SLA. Further research and enhancements can be explored based on the findings of this analysis. / Denna avhandling fokuserar på att adressera utmaningarna med resurshantering i molnmiljöer, specifikt i kontexten att köra resursoptimerade applikationer på Kubernetes. Skalan och tillväxten av molntjänster, tillsammans med arbetsbelastningarnas dynamiska natur, gör det svårt att effektivt hantera resurser och kontrollera kostnader. Syftet med denna avhandling är att utforska proaktiv autoskalning av virtuella resurser baserat på trafikbehov, med målet att förbättra den nuvarande reaktiva metoden, Horizontal Pod Autoscaler (HPA), som förlitar sig på fördefinierade regler och tröskelvärden. Genom att möjliggöra proaktiv autoskalning kan resurstilldelningen optimeras i förväg, vilket leder till förbättrad resursanvändning och kostnadsbesparingar. Målet är att hitta en balans mellan resursanvändning och risken för överträdelser av Service Level Agreements (SLA) samtidigt som resursanvändningen för mikrotjänster optimeras. Studien innefattar att generera förutsägelser och bedöma resursanvändning för både den nuvarande HPA-implementeringen och den föreslagna lösningen. Genom att jämföra resursanvändning och kostnadsimplikationer kan den ekonomiska genomförbarheten och fördelarna med att anta det nya tillvägagångssättet bestämmas. Analysen syftar till att ge värdefulla insikter i mönster för resursanvändning och möjligheter till optimering. Analysen visar betydande förbättringar i CPU-användning och resursförbrukning med den föreslagna metoden jämfört med den nuvarande HPA-implementeringen. Den proaktiva strategin möjliggör hantering av samma antal förfrågningar med färre replikor, vilket resulterar i förbättrad effektivitet. Den föreslagna lösningen har potential att tillämpas på alla typer av tjänster som körs på Kubernetes, med låga beräkningskostnader. Sammanfattningsvis visar analysen potentialen för resursoptimering och kostnadsbesparingar genom det föreslagna tillvägagångssättet. Genom att anta proaktiva strategier och noggrant förutsäga resursbehov kan organisationer uppnå effektiv resursanvändning, systemets robusthet och uppfyllnad av SLA:er. Vidare forskning och förbättringar kan utforskas baserat på resultaten av denna analys.

Autonomous vehicles have made milestone strides within the past decade. Advances up the autonomy ladder have come lock-step with the advances in machine learning, namely deep-learning algorithms and huge, open training sets. And while advances in CPUs have slowed, GPUs have edged into the previous decade's TOP 500 supercomputer territory. This new class of GPUs include novel deep-learning hardware that has essentially side-stepped Moore's law, outpacing the doubling observation by a factor of ten. While GPUs have make record progress, networks do not follow Moore's law and are restricted by several bottlenecks, from protocol-based latency lower bounds to the very laws of physics. In a way, the bottlenecks that plague modern networks gave rise to Edge computing, a key component of the Connected Autonomous Vehicle system, as the need for low-latency in some domains eclipsed the need for massive processing farms. The Connected Autonomous Vehicle ecosystem is one of the most complicated environments in all of computing. Not only is the hardware scaled all the way from 16 and 32-bit microcontrollers, to multi-CPU Edge nodes, and multi-GPU Cloud servers, but the networking also encompasses the gamut of modern communication transports. I propose a framework for negotiating, encapsulating and transferring data between vehicles ensuring efficient bandwidth utilization and respecting real-time privacy levels.

The thesis deals with selection of infrastructure virtualization platform focusing on containerization with sandboxing support and with following examination of its difculty. The work begins with an explanation of the basic technologies such as: virtualization, cloud computing and containerization, along with their representatives, that mediate the technology. A special scope is defned for cloud computing platforms: Kubernetes, OpenStack and OpenShift. Futhermore, the most suitable platform is selected and deployed using own technique so that it fullflls all the conditions specifed by thesis supervisor. Within the difculty testing of the selected platform, there are created scripts (mainly in the Bash language) for scanning system load, creating scenarios, stress testing and automation.

Företag som är intresserade av att gå över från ett traditionellttillvägagångssätt att driftsätta sin applikationsmiljö i en mer moderncontainerbaserad miljö saknas ofta den kunskap och erfarenhet som behövs.Det här arbetet syftar till att ge förslag till företag kring hur de bör gå tillvägaför att flytta sin nuvarande traditionella infrastrukturella lösning, vare sig detär fysiska eller virtuella servrar, till en containerbaserad lösning. Projektetsyftar också till att ge företag som är intresserade av en sådan migration enteoretisk grund att stå på för att undvika att gå i de fällor som är vanliga att gåi. Resultatet baseras på en litteraturstudie som i sin tur resulterade i ensammanfattning över vad som bör ingå i en migrationsstrategi samt ett antalpraktiskt tillämpningsbara beslutsträd.

The accelerating progress in network speeds and computing power permitted the architectural design paradigm to shift from monolithic applications to microservices. The industry moved from single-core and multi-threads, code-heavy applications, running on giant machines 24/7 to smaller machines, multi-cores single threads where computing power and memory consumption are managed very critically. With the advent of this novel approach to designing systems, traditional multi-tier applications have been broken down into hundreds of microservices that can be easily moved around, start, and stop quickly. In this context, scaling assumed a new meaning, rather than scaling up by adding more resources or computing power, now systems are scaled dynamically by adding more microservices instances. This contribution proposes a theoretical study and a practical experiment to investigate, compare and outline the performance improvements aid by the implementation of Protocol Buffers, Google's language-neutral, binary-based representational data interchange format over traditional text-based serialization formats in a modern, Cloud-Native, REST-based Java Microservice architecture. Findings are presented showing promising results regarding the implementation of Protobuf, with a significant reduction in response time (25.1% faster in the best-case scenario) and smaller payload size (72.28% better in the best-case scenario) when compared to traditional textual serialization formats while literature revealed out-of-the-box mechanisms for message versioning with backward compatibility.

With the exponential growth of virtualization and cloud computing over the last decade, many companies in the telecommunications sector have started their journey towards cloud migration by exchanging a lot of specialized hardware for virtualized solutions. With more and more applications running in a cloud environment, it became essential to run these applications on heterogeneous systems with shared underlying hardware and software resources. However, running these applications in a heterogeneous cloud environment often leads to  unpredictable and non-deterministic performance, as all the applications compete for the shared resources to improve their individual performance. This becomes a problem when the interference from the co-hosted applications starts affecting the performance of the critical applications running on the same server. Ericsson is therefore investigating a solution to dynamically manage the low-level hardware and software resources to get deterministic performance on applications deployed using Kubernetes.  In this thesis, the Intent Driven Orchestration (IDO) model developed by Intel is used as the baseline model. This model was then extended by adding another tool to the setup called Container Runtime Interface-Resource Manager (CRI-RM), which is used to manipulate low-level software and hardware resources managed by a Kubernetes cluster at runtime. The results achieved in this thesis suggest that it is possible to get deterministic performance for an application deployed using Kubernetes, by identifying and isolating the CPU cores in the cluster on which the application is running.

The growth of distributed applications stand on a foundation of containers and their communication and have seen the rise and fall of many implementations throughout the years with a mix of proprietary and open sources. Today there are two implementations widely used as a result of the popularity of the huge project Kubernetes: CRI-O and Containerd. Both with the edge responsibility of managing containers using similar underlying software raising the question; do they have any implications on the containers they spawn? This thesis investigate these implementations from a performance perspective with a custom developed tool for direct communication to them and run a suite of benchmarks within the containers created by each. The suite consists of tests for throughput, latency, cpu, memory, random file read/write and sequential file read/write. Results conclude they perform similarly in all, but the file tests which showed overall CRI-O dominating in write speed and Containerd dominating the read speed.

Due to the growing complexity of systems and high demands on availability, fault tolerance, and scalability, more stateful applications are being moved to Kubernetes. There are two problems associated with this: (1) At the moment, there is a lack of industry standards when it comes to what is essential in a lifecycle management framework for stateful applications on top of Kubernetes. (2) Due to inadequate knowledge of the existing frameworks in the area and a lack of comparisons between them, there is no consensus on which framework to use. To solve these problems, this study reviews the field for existing frameworks and then evaluates the framework based on a set of metrics. The frameworks chosen for comparison during the study are (1) Operator Framework, (2) Shell Operator, (3) Kopf, and (4) KUDO. When comparing the frameworks, it becomes apparent that Operator Framework should be used in most cases. Kopf or Shell Operator can be used when creating simple scheduled activities or when the developing team is very knowledgeable in Python or Bash.