When discussing starting a new project or developing a roadmap for an existing project, the options for how to run workloads have never been more extensive. We live in an era spoiled by a choice of platforms - you can choose between open-source tools, paid services, enterprise products, and a bunch of other things. Because of this, it became more difficult to make a choice decision - the chances of getting "choice paralysis" increase with the increase in options. In such circumstances, it is fair to ask the question: are containers still a reasonable choice now and in the future, or have we already outgrown them? To answer this question, you need to consider alternatives and compare them to containers.

Serverless

The next logical step after containers is serverless solutions. Services such as AWS Lambda and Google Cloud Functions make it easy to operate serverless applications, especially those that are event driven in nature. When you consider the ease of working with application frameworks like Serverless Framework, we get a simple, developer-driven workflow that allows you to go from idea to production in a very short time. This workflow can be great for prototyping APIs or quickly developing new features for existing products. One of the greatest strengths of the serverless architecture (especially when running applications on a public cloud provider like AWS) is that you only pay for actively used computing resources;that is, you do not pay for a simple system. In the long term, this can provide significant cost savings compared to the "always on" architecture, but only under certain conditions. There is a threshold after which the cost of running an application in a serverless environment becomes higher and performance is lower compared to the same application running in a dedicated VM, where you pay not for calling the application, but for the hourly rate. Let's compare serverless versus containers:where you pay not for calling the application, but the hourly rate. Let's compare serverless versus containers:where you pay not for calling the application, but the hourly rate. Let's compare serverless versus containers:

:

Platform-As-A-Service (PaaS)

They are similar to serverless, but have their own unique Platform-As-A-Service (PaaS) features like Heroku and CloudFoundry. Typically PaaS differ from serverless in that they are designed for “always running” services rather than event-driven ones, but they are similar to them in that, similarly to serverless, they provide convenient workflows for developers. Internally, most of these solutions actually execute your code in containers, but most of them are abstracted from the user, so they are often positioned as "buildpacks" - ready-made containers with certain features or language-dependent packages installed in them. It is this abstraction that makes PaaS products convenient - all the troublesome aspects of running an application in production are abstracted from the user.However, this can be one of the disadvantages of PaaS: it can be difficult to free applications from PaaS platforms and move them to another platform if necessary. In addition, on some incompletely mature platforms, native integration with external services (databases, caches, queues, etc.) may be limited or absent altogether, which significantly limits the architecture options. Plus, abstraction and ease of use come at a price: PaaS platforms tend to be more expensive than do-it-yourself IaaS like AWS or GCP.caches, queues, etc.) may be limited or absent altogether, which significantly limits the architecture options. Plus, abstraction and ease of use come at a price: PaaS platforms tend to be more expensive than do-it-yourself IaaS like AWS or GCP.caches, queues, etc.) may be limited or absent altogether, which significantly limits the architecture options. Plus, abstraction and ease of use come at a price: PaaS platforms tend to be more expensive than do-it-yourself IaaS like AWS or GCP.

:

No-Code

No-code solutions are becoming more popular as a means to quickly grow a startup, especially among non-technical organizers. The ability to create an entire web platform without having to learn code is attractive, and for those who don't know how to code, it is even necessary. Modern no-code solutions blur the boundaries of the intersection of business processes and software; Business logic that could take weeks to develop in the past can now be created in minutes or hours on the no-code platform. Again, this can be a tremendous success for non-technical people or groups, but does this approach generally apply to software development? Paradigmically, no-code solutions are similar to serverless in that both concepts work in an event-based management model,however, no-code solutions have one major flaw that the other platforms on our list do not: overly tied to the solution provider. At the moment, I am not aware of any platform that allows you to transfer a no-code application from one platform to another. If you decide to write your base application in Microsoft Power Automate or Zoho Creator, then you will remain there until you rewrite it in something else.

:

So where are containers among all these technologies? I tend to think of containers as fundamental building blocks of architecture, as tiny pieces of an application that don't make sense to separate. Regardless of whether you are running microservices or an entire monolith inside containers, the container should be the smallest amount of code that can be deployed while maintaining its functionality. At the simplest level, containers are just a subset of the kernel's functionality. Features such as resource isolation, network throttling, and the like that are part of the Linux operating system have been redesigned to make them easier for people to use. It is perfectly possible to start a process and manage it using cgroups, virtual networks, iptables and other functions that mimic the Docker container, however, such applications,how Docker and Podman make these features easy to use so you don't have to do it all by hand. It is this use of kernel functions that provides containers with portability. If you have a Linux machine with a fairly modern kernel, you can run almost any container without any problems. However, this simplicity comes with a price, and the cost is the complexity of the operation. To deploy production, it is not enough to simply deploy one container on a bare VM. For a "correct" implementation, you need some sort of container management that increases complexity and operational costs. However, despite the increased complexity, containers make up for it with their flexibility and portability.It is this use of kernel functions that provides containers with portability. If you have a Linux machine with a fairly modern kernel, you can run almost any container without any problems. However, this simplicity comes with a price, and the cost is the complexity of the operation. To deploy production, it is not enough to simply deploy one container on a bare VM. For a "correct" implementation, you will need some sort of container management that adds complexity and operational cost. However, despite the increased complexity, containers make up for it with their flexibility and portability.It is this use of kernel functions that provides containers with portability. If you have a Linux machine with a fairly modern kernel, you can run almost any container without any problems. However, this simplicity comes with a price, and the cost is the complexity of the operation. To deploy production, it is not enough to simply deploy one container on a bare VM. For a "correct" implementation, you will need some sort of container management that adds complexity and operational cost. However, despite the increased complexity, containers make up for it with their flexibility and portability.and this price is the complexity of the operation. To deploy production, it is not enough just to deploy one container on a bare VM. For a "correct" implementation, you need some sort of container management that increases complexity and operational costs. However, despite the increased complexity, containers make up for it with their flexibility and portability.and this price is the complexity of the operation. To deploy production, it is not enough just to deploy one container on a bare VM. For a "correct" implementation, you will need some sort of container management that adds complexity and operational cost. However, despite the increased complexity, containers make up for it with their flexibility and portability.

Pros:

Flexibility, portability
The always-on architecture allows for different types of paradigms
Ease of local testing and development

Minuses:

Production requires container management
Compute usage in "always on" mode can cost more than serverless, but it depends on the load
More work required to prepare for production

Conclusion

While your personal choice can be very application and workload dependent, my conclusion is very simple: containers are still very relevant and will go on for a very long time. Despite the increased complexity, their portability and level of control allow engineers to do exactly what they want without having to reverse engineer a solution based on something like Heroku.

Using our cloud servers you can deploy your Docker containers seamlessly. This is just one of the millions of challenges that you can accomplish with MacLeod !

Register using the link above or by clicking on the banner and get a 10% discount for the first month of renting a server of any configuration!

Are containers still relevant?