THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
66
https://www.theamericanjournals.com/index.php/tajet
PUBLISHED DATE: - 27-07-2024
https://doi.org/10.37547/tajet/Volume06Issue07-08
PAGE NO.: - 66-80
USING CONTAINERIZATION IN THE DEVELOPMENT
AND DEPLOYMENT OF CYBERSPORTS PLATFORMS
Vadym Bychkov
Chief Technology Officer at Hawk Live LLC Batumi, Georgia
INTRODUCTION
In the context of the rapid development of the
eSports industry and the increasing scale of
eSports events, the development and deployment
of high-load platforms have become critically
important tasks. Modern eSports platforms must
ensure high performance, scalability, and fault
tolerance to serve millions of users simultaneously
[1,2]. In this regard, the application of
containerization technologies appears to be a
promising approach to addressing these
challenges.
Containerization, as a method of operating system-
level virtualization, offers several significant
advantages in the development and operation of
distributed systems. It provides application
isolation, environment consistency throughout the
software lifecycle, and efficient use of computing
resources. For eSports platforms, which are
characterized by high load dynamism and the need
for rapid scaling, containerization can become a
key factor in achieving the required system
performance and reliability.
The relevance of this research is also due to the fact
that despite the widespread adoption of container
technologies in the software development
industry, their application in the specific context of
eSports platforms remains insufficiently studied.
There is a need to systematize approaches to
architecture design, performance optimization,
and ensuring the fault tolerance of containerized
eSports platforms.
Therefore, the main objective of this study is to
develop a comprehensive approach to using
containerization in the creation and deployment of
eSports platforms, ensuring optimal system
performance, scalability, and fault tolerance.
To achieve this goal, the following tasks have been
RESEARCH ARTICLE
Open Access
Abstract
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
67
https://www.theamericanjournals.com/index.php/tajet
identified:
1. Analyze the specific requirements and
constraints characteristic of eSports platforms that
influence the choice of architectural solutions and
containerization technologies.
2.
Investigate
existing
approaches
to
containerizing high-load systems and evaluate
their applicability in the context of eSports
platforms.
3. Develop an architectural model of a
containerized eSports platform that meets the
requirements for performance, scalability, and
fault tolerance.
4. Propose a methodology for optimizing the
performance of containerized components of the
eSports platform, including aspects of caching,
asynchronous
processing,
and
database
optimization.
5. Develop a strategy to ensure fault tolerance and
high availability of the containerized eSports
platform, considering the specifics of distributed
systems.
6. Formulate recommendations for organizing
continuous integration and delivery (CI/CD)
processes for containerized eSports platforms.
7. Conduct an experimental study on the
effectiveness of the proposed approaches using a
prototype eSports platform.
This study aims to form a comprehensive
understanding of the process of developing and
deploying containerized eSports platforms,
considering modern technological trends and the
specific requirements of the eSports industry. The
results of this research can be used by software
developers and architects to create high-
performance, scalable, and reliable eSports
platforms capable of meeting the growing needs of
the industry.
THEORETICAL FOUNDATIONS
Containerization, as a fundamental concept in
modern software development, represents an
operating system-level virtualization method. This
technology is based on two key mechanisms of the
Linux kernel: namespaces and control groups
(cgroups).
Namespaces provide resource isolation at the
kernel level, creating the illusion for each container
of operating in its own isolated environment. There
are several types of namespaces:
1.
PID namespace: isolates process identifiers
2.
Network
namespace:
isolates
network
resources
3.
Mount namespace: isolates file system mount
points
4.
UTS namespace: isolates host and domain
names
5.
IPC
namespace:
isolates
inter-process
communication resources
6.
User namespace: isolates user and group
identifiers
Control groups (cgroups) allow for the limitation
and accounting of resource usage by groups of
processes. They provide control over resources
such as CPU, memory, disk I/O, and network traffic
[3].
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
68
https://www.theamericanjournals.com/index.php/tajet
Figure 1: Containerization Architecture
In
the
context
of
eSports
platforms,
containerization becomes particularly significant
due to the industry's specific requirements. Let's
consider
the
key
aspects
of
applying
containerization in this field:
1. Microservice Architecture: Decomposing the
system into small, loosely coupled services allows
for high flexibility and scalability. Each
microservice can be packaged in a separate
container, ensuring isolation and independent
deployment.
2. Container Orchestration: Kubernetes, as the de
facto standard in this area, provides powerful tools
for managing the lifecycle of containers. Key
concepts of Kubernetes include:
- Pods: the smallest deployable unit, grouping one
or more containers
- Services: an abstraction defining a logical set of
pods and access policies to them
- Deployments: describes the desired state for
deploying pods
- Ingress: manages external access to services
within the cluster
3. State Management: Effective state management
is crucial for eSports platforms. The following
approaches are applied:
- Persistent Volumes in Kubernetes for data
storage
- Distributed data storage (e.g., Cassandra,
CockroachDB)
- Caching using in-memory databases (Redis,
Memcached)
4. Real-Time Event Processing: To ensure low
latency and high throughput, the following are
used:
- Stream processing (Apache Kafka, Apache Flink)
- Reactive programming (RxJava, Project Reactor)
5. Monitoring and Fault Tolerance: These are
critically important aspects for eSports platforms,
implemented using:
- Distributed tracing (Jaeger, Zipkin)
- Metric-based monitoring (Prometheus, Grafana)
- Fault tolerance patterns (Circuit Breaker,
Bulkhead)
Namespaces | cgroups
Container engine
(Docker, containerd, CRI-0)
Linux kernel
Infrastructure
Libraries/Dependencies
Appendix
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
69
https://www.theamericanjournals.com/index.php/tajet
Table 1: Comparison of Traditional Approach and Containerization for eSports Platforms
Aspect
Traditional Approach
Containerization
Component Isolation
Limited
High
Scalability
Complex, time-consuming
Fast, automated
Environment Consistency
Problematic
Guaranteed
Resource Efficiency
Low
High
Deployment Speed
Slow
Fast
Rollback of Changes
Complex, risky
Simple, safe
Continuous Integration
Difficult
Easily achievable
The theory of distributed systems plays a key role in designing containerized eSports platforms. The CAP
theorem (Consistency, Availability, Partition tolerance) is particularly significant, asserting that it is
impossible to simultaneously achieve all three properties in a distributed system. In the context of esports
platforms, one often has to choose between strict consistency and high availability [4].
Figure 2: Visualization of the CAP theorem in the context of eSports platforms
To ensure high performance and scalability in
containerized eSports platforms, various patterns
and technologies are applied:
1. CQRS (Command Query Responsibility
Segregation): separates read and write operations
to optimize performance.
2. Event Sourcing: stores the system state as a
sequence of events to ensure auditability and the
ability to replay the state.
3.
Saga Pattern: coordinates distributed
transactions in a microservice architecture.
4.
Service
Mesh
(e.g.,
Istio):
manages
communication between microservices, ensuring
security and observability.
The application of these concepts and technologies
in the context of containerization allows for the
creation of high-performance, scalable, and fault-
tolerant eSports platforms capable of meeting the
growing needs of the industry [3-5].
3. Application of Containerization in eSports
Platforms
The application of containerization in eSports
platforms requires a comprehensive examination
of architectural solutions, aspects of scalability and
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
70
https://www.theamericanjournals.com/index.php/tajet
fault tolerance, as well as security and component
isolation issues.
Architectural solutions in the context of
containerizing eSports platforms predominantly
rely on the microservice paradigm. This is driven
by the need to ensure high scalability and flexibility
of the system. A microservice architecture
implemented with containers allows for the
effective decomposition of a complex eSports
platform into individual functional components,
such as matchmaking services, tournament
management, analytics, and streaming [6].
Consider a typical architecture of a containerized
eSports platform (Figure 3).
Figure 3: Architecture of a Containerized eSports Platform
Each component in this architecture can be
implemented as a separate container or group of
containers, ensuring isolation and independent
deployment. Using an API Gateway (e.g., Nginx or
Traefik) allows centralized management of request
routing and the application of security policies.
Scalability and fault tolerance are critical aspects
for eSports platforms, given the high load dynamics
and the requirement for uninterrupted service
operation. Containerization provides effective
mechanisms to address these challenges.
Horizontal scaling is achieved by increasing the
number of container replicas for specific services.
For example, during major tournaments, a
significant increase in the capacity of matchmaking
and streaming services may be required. Container
orchestrators, such as Kubernetes, provide
mechanisms for automatic scaling based on
resource usage metrics or custom metrics.
Consider an example configuration of a Horizontal
Pod Autoscaler in Kubernetes for a matchmaking
service:
apiVersion: autoscaling/v2beta1
kind: HorizontalPodAutoscaler
metadata:
name: matchmaking-scaler
spec:
scaleTargetRef:
apiVersion: apps/v1
Authentication
(Keycloak)
AP1 Gateway
(Nginx/Traefik)
Matchmaking
(Custom
Service)
Analytics
(Spark/Flink)
Tournament
management
Streaming
(WebRTC/
RTMP)
Cache (Redis)
Database
(PostgreSQL/
Cass-andra)
Message
Queue (Kafka)
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
71
https://www.theamericanjournals.com/index.php/tajet
kind: Deployment
name: matchmaking-service
minReplicas: 3
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
targetAverageUtilization: 70
- type: Pods
pods:
metricName: qps
targetAverageValue: 100
This configuration ensures the automatic scaling of
the matchmaking service based on CPU load and
queries per second (QPS), allowing the system to
adapt to real-time load changes.
Fault tolerance in containerized systems is
achieved by distributing the load among multiple
service instances and automatically recovering
from failures. Kubernetes provides self-healing
mechanisms, automatically restarting containers
upon failures and moving pods to healthy cluster
nodes.
To ensure the high availability of stateful
components, such as databases, distributed data
storage solutions are applied. For instance, using
Cassandra or CockroachDB allows the creation of a
fault-tolerant cluster for storing data on users,
tournaments, and matches.
Security and isolation of components are critically
important for eSports platforms, considering the
sensitivity of the processed data and potential risks
associated with cyber threats. Containerization
provides an additional layer of isolation compared
to traditional monolithic architectures.
The following practices are applied to ensure the
security of containerized applications:
1.
Using minimal base images (e.g., Alpine Linux)
to reduce the attack surface.
2.
Scanning container images for vulnerabilities
(e.g., using Clair or Trivy).
3.
Applying container-level security policies (e.g.,
using AppArmor or SELinux).
4.
Encrypting communications between services
with mTLS (mutual TLS).
Consider the following example of a NetworkPolicy
configuration in Kubernetes to isolate network
traffic:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: matchmaking-network-policy
spec:
podSelector:
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
72
https://www.theamericanjournals.com/index.php/tajet
matchLabels:
app: matchmaking
policyTypes:
- Ingress
- Egress
ingress:
- from:
- podSelector:
matchLabels:
app: api-gateway
ports:
- protocol: TCP
port: 8080
egress:
- to:
- podSelector:
matchLabels:
app: database
ports:
- protocol: TCP
port: 5432
This policy restricts incoming traffic to the
matchmaking service, allowing connections only
from the API Gateway, and restricts outgoing
traffic, allowing connections only to the database.
To ensure user data security and the integrity of
competitions on eSports platforms, special
attention is paid to authentication and
authorization mechanisms. Using specialized
services like Keycloak, combined with JWT (JSON
Web Tokens), enables the implementation of a
robust access management system.
Performance analysis of containerized eSports
platforms shows that with proper configuration
and optimization, high efficiency and low latency
can be achieved, which is critically important for
online gaming and streaming. Technologies such as
gRPC for inter-service communication and NATS
for messaging minimize overhead in container
communication [7].
To evaluate the effectiveness of containerization in
eSports platforms, the following metric can be
used:
Efficiency Index (EI) = (Throughput * Scalability) /
(Resource Usage * Deployment Complexity)
where:
-
Throughput: number of requests processed per
second
-
Scalability: maximum number of concurrent
users
-
Resource Usage: CPU and memory usage
-
Deployment Complexity: time required for
system deployment and updates
The higher the EI value, the more effective the use
of containerization in the platform.
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
73
https://www.theamericanjournals.com/index.php/tajet
4. Practical Implementation of Containerization in
an eSports Platform
1. Architectural Solution
To implement a modern eSports platform, it is
proposed to use a microservice architecture with
event-driven interaction [8,9]. This approach
ensures high scalability, development flexibility,
and the ability to deploy components
independently.
Key system components:
1.
API Gateway
2.
Authentication and Authorization Service
3.
Tournament Management Service
4.
Statistics and Analytics Service
5.
Streaming Service
6.
Chat Service
7.
Payment Processing Service
The API Gateway serves as a single entry point for
client applications, providing request routing,
authentication, and authorization. This abstracts
clients from the internal structure of the
microservices and ensures a uniform interaction
interface.
Inter-service communication is carried out through
asynchronous message exchange via Apache Kafka.
This approach ensures loose coupling of services,
increases system fault tolerance, and allows
efficient scaling of individual components
independently.
2. Containerization and Orchestration
Containerization using Docker allows the creation
of isolated, portable, and easily scalable system
components. Each microservice is packaged into a
separate Docker container, ensuring environment
consistency throughout the application's lifecycle,
from development to production.
Kubernetes is used for container orchestration,
providing powerful tools for automatic scaling,
load
balancing,
and
system
self-healing.
Kubernetes abstracts developers from the specific
infrastructure, allowing them to focus on business
logic development.
Helm is used for dependency management and
simplifying the deployment process. It allows
describing complex Kubernetes configurations as
parameterized templates, significantly simplifying
the management of different environments
(development, testing, production).
Consider an example Helm Chart configuration for
the Tournament Management Service:
apiVersion: v2
name: tournament-service
description: Tournament management service for eSports platform
version: 1.0.0
dependencies:
- name: common
version: 1.x.x
repository: https://charts.bitnami.com/bitnami
---
# values.yaml
replicaCount: 3
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
74
https://www.theamericanjournals.com/index.php/tajet
image:
repository: esports/tournament-service
tag: 1.0.0
resources:
limits:
cpu: 500m
memory: 512Mi
requests:
cpu: 250m
memory: 256Mi
autoscaling:
enabled: true
minReplicas: 3
maxReplicas: 10
targetCPUUtilizationPercentage: 80
ingress:
enabled: true
annotations:
kubernetes.io/ingress.class: nginx
cert-manager.io/cluster-issuer: letsencrypt-prod
hosts:
- host: tournament.esports-platform.com
paths: ["/"]
tls:
- secretName: tournament-tls
hosts:
- tournament.esports-platform.com
config:
KAFKA_BOOTSTRAP_SERVERS: "kafka-headless:9092"
DATABASE_URL: "postgresql://user:password@postgres:5432/tournaments"
This configuration ensures:
-
Horizontal Pod Autoscaling (HPA) based on
CPU load, allowing automatic adaptation to
load changes.
-
Ingress setup with TLS termination for secure
access to the service from outside the cluster.
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
75
https://www.theamericanjournals.com/index.php/tajet
-
Injection of configuration parameters such as
Kafka and database addresses, simplifying
configuration management across different
environments.
3. Performance Optimization
To achieve maximum performance, the following
techniques are applied:
1.
Caching with Redis
2.
Database query optimization
3.
Asynchronous processing of long-running
operations
Caching significantly reduces the load on the
database and decreases system response time.
Redis is chosen for its high performance and
support for various data structures.
Consider an example of optimizing a tournament
statistics query using caching:
func (s *TournamentService) GetTournamentStats(ctx context.Context, tournamentID
string) (*TournamentStats, error) {
cacheKey := fmt.Sprintf("tournament_stats:%s", tournamentID)
// Attempt to get data from cache
cachedStats, err := s.redisClient.Get(ctx, cacheKey).Result()
if err == nil {
var stats TournamentStats
if err := json.Unmarshal([]byte(cachedStats), &stats); err == nil {
return &stats, nil
}
}
// If data is not in cache, query the database
stats, err := s.repository.GetTournamentStats(ctx, tournamentID)
if err != nil {
return nil, err
}
// Save the result to cache
jsonStats, _ := json.Marshal(stats)
s.redisClient.Set(ctx, cacheKey, jsonStats, 5*time.Minute)
return stats, nil
}
This approach allows:
- Reducing the load on the database by caching
frequently requested data.
- Decreasing system response time, especially for
complex statistics queries.
- Increasing system resilience to peak loads.
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
76
https://www.theamericanjournals.com/index.php/tajet
4. Ensuring Fault Tolerance
To enhance system fault tolerance, the following
methods are applied:
1. Circuit Breaker to prevent cascading failures
2. Retry mechanisms with exponential backoff
3. Graceful Degradation when non-critical services
are unavailable
The Circuit Breaker prevents repeated calls to non-
functional services, helping to avoid system
overload and speed up recovery after failures.
Example of Circuit Breaker Implementation Using
the go-circuit-breaker Library:
import "github.com/rubyist/circuitbreaker"
var cb *circuit.Breaker
func init() {
var st circuit.Settings
st.Name = "tournament-service"
st.Timeout = 10 * time.Second
st.ReadyToTrip = func(counts circuit.Counts) bool {
failureRatio := float64(counts.TotalFailures) / float64(counts.Requests)
return counts.Requests >= 3 && failureRatio >= 0.6
}
cb = circuit.NewBreakerWithSettings(&st)
}
func (s *TournamentService) CreateTournament(ctx context.Context, tournament
*Tournament) error {
return cb.Call(func() error {
return s.repository.CreateTournament(ctx, tournament)
}, 0)
}
This approach:
-
Prevents cascading failures when one of the
system components fails.
-
Allows the system to recover faster after
failures.
-
Ensures more predictable system behavior
under partial degradation conditions.
5. Monitoring and Logging
Effective monitoring and logging are critical for
ensuring the reliability and performance of a
distributed system. It is proposed to use:
1. Prometheus for metrics collection
2. Grafana for visualization
3. ELK stack (Elasticsearch, Logstash, Kibana) for
centralized logging
Prometheus efficiently collects metrics from
various system components, including Kubernetes
and individual microservices. Grafana provides
powerful tools for visualizing these metrics and
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
77
https://www.theamericanjournals.com/index.php/tajet
creating informative dashboards.
Example of Prometheus configuration for
monitoring a Kubernetes cluster:
apiVersion: monitoring.coreos.com/v1
kind: Prometheus
metadata:
name: prometheus
labels:
prometheus: k8s
spec:
serviceAccountName: prometheus
serviceMonitorSelector:
matchLabels:
team: frontend
ruleSelector:
matchLabels:
team: frontend
resources:
requests:
memory: 400Mi
enableAdminAPI: false
This configuration:
- Defines a Prometheus server for monitoring the
Kubernetes cluster.
- Sets selectors for discovering services and
monitoring rules.
- Limits the resources allocated to Prometheus,
which is important for efficient cluster resource
usage.
6. Continuous Integration and Delivery (CI/CD)
Automating the development and deployment
process is crucial for ensuring rapid iteration and
reliable updates. It is proposed to use GitLab CI/CD
with the following stages:
1.
Build and test
2.
Static code analysis
3.
Vulnerability scanning
4.
Docker image build and publish
5.
Deployment to the Kubernetes cluster
Example of GitLab CI/CD Configuration for the
Tournament Management Service:
stages:
- build
- test
- analyze
- publish
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
78
https://www.theamericanjournals.com/index.php/tajet
- deploy
variables:
DOCKER_REGISTRY: registry.gitlab.com/esports-platform
build:
stage: build
image: golang:1.17
script:
- go build -o tournament-service ./cmd/tournament-service
test:
stage: test
image: golang:1.17
script:
- go test -v -cover ./...
analyze:
stage: analyze
image: golangci/golangci-lint:v1.45
script:
- golangci-lint run
publish:
stage: publish
image: docker:20.10
services:
- docker:20.10-dind
script:
- docker build -t $DOCKER_REGISTRY/tournament-service:$CI_COMMIT_SHA .
- docker push $DOCKER_REGISTRY/tournament-service:$CI_COMMIT_SHA
deploy:
stage: deploy
image: bitnami/kubectl:1.22
script:
- kubectl set image deployment/tournament-service tournament-
service=$DOCKER_REGISTRY/tournament-service:$CI_COMMIT_SHA
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
79
https://www.theamericanjournals.com/index.php/tajet
- kubectl rollout status deployment/tournament-service
This configuration ensures:
-
Automatic code build and testing with each
commit.
-
Conducting static code analysis to identify
potential issues at early stages.
-
Automatic building and publishing of Docker
images.
-
Automatic deployment of the new service
version in the Kubernetes cluster.
This approach significantly accelerates the
development and deployment process, minimizes
human errors, and ensures environment
consistency throughout the application's lifecycle
[8-10].
The
proposed
practical
implementation
demonstrates a comprehensive approach to
containerization and deployment of an eSports
platform. The use of microservice architecture
combined with containerization and orchestration
ensures high scalability, fault tolerance, and system
flexibility.
It is important to note that this solution is not static.
It provides a solid foundation for the further
development and scaling of the eSports platform,
allowing for flexible adaptation to the growing
needs of users and changes in the industry. As the
platform grows and the load increases, the
architecture can evolve, incorporating aspects such
as
geographic
distribution,
multi-cluster
deployment,
and
further
performance
optimization.
CONCLUSION
This study presents a comprehensive analysis of
the application of containerization in the
development and deployment of eSports platforms.
Key aspects of using container technologies in the
context of the specific requirements of the eSports
industry, including architectural solutions,
scalability, fault tolerance, and security, were
examined during the course of the work.
The research results lead to the following
conclusions:
1. Containerization provides an effective toolkit for
creating flexible, scalable, and fault-tolerant
eSports platforms. A microservice architecture
implemented using containers allows for the
optimal decomposition of complex systems into
independent components, which is particularly
important for the dynamically evolving eSports
industry.
2. The use of container orchestrators, such as
Kubernetes, ensures automatic scaling and system
self-healing, which is critically important for
managing the highly dynamic loads characteristic
of eSports events.
3. Containerization enhances the security of
eSports platforms by isolating components and
enabling granular security policies at the level of
individual services.
4. The efficiency of containerization in eSports
platforms can be quantitatively assessed using the
proposed Efficiency Index, which takes into
account throughput, scalability, resource usage,
and deployment complexity.
5.
Despite
significant
advantages,
the
implementation of containerization requires
careful planning, performance optimization, and
consideration of the specific requirements of the
eSports industry, such as low latency and high
service availability.
The conducted research contributes to the
understanding of the practical aspects of applying
container technologies in the development of
eSports platforms. The proposed methodological
approaches and architectural solutions can be used
by developers and architects to create high-
performance and reliable systems capable of
meeting the growing needs of the eSports industry.
REFERENCES
1.
Taylor T. L. Watch me play: Twitch and the
rise of game live streaming //Watch Me Play.
–
Princeton University Press, 2018.
2.
Scholz T. M., Scholz T. M., Barlow. eSports is
Business.
–
Springer
International
Publishing, 2019.
–
Vol. 15.
THE USA JOURNALS
THE AMERICAN JOURNAL OF ENGINEERING AND TECHNOLOGY (ISSN
–
2689-0984)
VOLUME 06 ISSUE07
80
https://www.theamericanjournals.com/index.php/tajet
3.
Burns B. et al. Kubernetes: up and running.
–
"O'Reilly Media, Inc.", 2022.
4.
Newman S. Building microservices.
–
"O'Reilly Media, Inc.", 2021.
5.
Creswell J. W., Creswell J. D. Research design:
Qualitative,
quantitative,
and
mixed
methods approaches.
–
Sage publications,
2017.
6.
Pahl C. et al. Cloud container technologies: a
state-of-the-art review //IEEE Transactions
on Cloud Computing.
–
2017.
–
T. 7.
–
No. 3.
–
pp. 677-692.
7.
Bernstein D. Containers and cloud: From lxc
to docker to kubernetes //IEEE cloud
computing.
–
2014.
–
T. 1.
–
No. 3.
–
pp. 81-
84.
8.
Arundel J., Domingus J. Cloud Native DevOps
with Kubernetes: building, deploying, and
scaling modern applications in the Cloud.
–
O'Reilly Media, 2019.
9.
Shkuro Y. Mastering Distributed Tracing:
Analyzing performance in microservices and
complex systems.
–
Packt Publishing Ltd,
2019.
10.
Nygard M. Release it!: design and deploy
production-ready software.
–
2018.
