Infrastructure & DevOps
We build infrastructure on Eluvia in a modern and efficient way
The heart of our infrastructure is the Docker virtualization technology. Docker assists developers right from the start by simplifying the configuration of their local development environment, but its true value becomes evident during the deployment of applications into production. Here, especially in combination with the orchestration technology Kubernetes (k8s), we build a stable, flexible, and scalable runtime environment for our systems.
These are soaring words, understandable perhaps only to experts. Therefore, let us explain the situation with the two examples:
Your application is already working happily, but suddenly an error occurs (say, caused by an incompatible change in a third-party technology) that significantly prevents your clients from working with the application, and therefore you from making money. Within the SLA, we quickly catch the error and modify the code into a functional form. Thanks to the automation and virtualization, we can get the fix into the production in practically a few minutes and update the application without any downtime. We do not have to wait until the evening for the service window, when it is possible to make a several-minute outage. Everything is done with the snap of a finger, transparently and your clients only notice that their key function is stepping on like a watch again.
Not enough? What about another example?
You are doing well. The business is growing and it also brings new users to your application. The original configuration did not allow for such demand and is starting to be a bit slow. You simply run out of resources from which the application draws - CPU power, memory and disk space. But this is no problem for us. Thanks to Docker / Kubernetes virtualization, we are able (again completely transparently and without downtime) to scale the application to the width, i.e. to add new servers, new performance and memory to suit the new requirements. And the best part is that we don't have to modify a single line of code to do that.
Automatic pipelines make our lives easier.
Our ingenious engineers have built a bunch of pipelines that automatically test our source code and compile it into Docker images – basic building blocks of our runtime architecture that can be run universally in a variety of virtualized environments. To do this, we use various Continuous Integration / Continuous Deployment Services (CI/CD), such as Gitlab.
We are blind without monitoring.
It is obvious. For reliable error debugging, whether functional errors or performance problems, it is crucial to keep the application under control. We store application logs, monitor resource usage, including CPU, memory, and disk space, and automatically report unexpected exceptions to Sentry or other tools based on OpenTelemetry principles.
It does not matter what individual parts of the infrastructure we deal with. The important thing is that we solve them. We, Eluvians, take care of our children, we care about them and we are constantly on the lookout. We, Eluvians, have control over the matter.