Engine Yard Kontainers and NoOps


DevOps benefits at a fraction of the cost

DevOps, Containers, and Kubernetes are trends and technologies that have changed the way IT organizations operate. However, adopting these practices can involve a sizable learning curve and an investment of time and resources beyond the reach of some organizations. The emerging NoOps paradigm seeks to fill the void by creating a model for standard best-in-class operations that frees developers from managing infrastructure and reduces the overall operational burden. EngineYard Kontainers (EYK) is a platform that brings the vision of NoOps to life.


The Evolution of DevOps

DevOps combines software development and IT operations into a single agile process. The developers who write the software also manage deployments and the operations of their application. This approach results in faster deliveries, improved communication, and better innovation throughout the life cycle. However, the GitLab Global Developer Report 2019 highlighted that only 28% of developers called their DevOps implementations “good.” A third described it as “fair” and 17% said it was “poor.”

It’s clear that there is a large degree of variation in how DevOps is practiced. Projects often experience this disparity based on their allocation of resources. DevOps automation tasks are often pushed to the backlog, or even post-launch, in favor of work viewed as being in the critical path to code-complete.

For organizations where DevOps is a priority, continual infrastructure upgrades and a lack of standards remain a challenge. This is a pattern seen in the adoption of many new technologies and processes. Early adopters create deployment and operational scripts that work for their project running on top of their chosen Infrastructure-as-a-Service (IaaS). However, without clear standards in place, this results in numerous custom implementations across the organization. Additionally, infrastructure upgrades often require rewiring of these scripts, a task that consumes even more developer time and energy.

Thus, a key challenge of the DevOps paradigm has been that time spent on operations takes developer time away from higher-value add activities, such as building new features. The deployment cadence has increased, but with it comes a larger drain on staff time and resources. With 43% of developers indicating they deploy at least once or more a day, the benefits of DevOps come at a cost.

This is where NoOps enters the picture. Rather than various scripts and bespoke implementations, a standard deployment stack is used based on years of experience and best practices. A Platform-as-a-Service (PaaS) such as EYK provides fully automated deployments to a hosting platform which includes built-in monitoring and auto-scaling. This drastically reduces the time spent on operations, yet still allows developers to iterate and deploy quickly. This results in more time for engineers to innovate and focus on software development.


Containers as Self-Describing Deployment Artifacts


For a platform to take arbitrary code and deploy it, a mechanism is needed to decouple the software from the deployment. This mechanism must be able to package the application and capture all necessary production environment requirements. Containers are used to accomplish this very goal.

You might also like:   Up Your DevOps Game: It’s Time for NoOps

Containers package your software so it can be deployed in a reliable and predictable manner. This makes application deployment easier than ever before. Docker is a technology that virtualizes the user space of an operating system in the form of a container. It provides a means to specify and create an image of the container which includes all deployment artifacts, software, and even configuration files that will be deployed. Specifications for the container image are defined in a Dockerfile. From this image, deployable units are constructed that contain all the runtime dependencies, hence the inherent reliability of container deployments. 

Note that continuous integration is not reimagined as a part of container adoption. Rather, containers are used to enable continuous delivery automation through increased speed, agility, and flexibility. Any service-based architecture can leverage this flexibility by hosting services in containers that are scaled individually.

The portability of containers helps drive flexibility. In terms of size, container images have a much smaller footprint when compared to their Virtual Machine (VM) counterparts. Containers can be built and deployed on any supported runtime environment. Kubernetes is a common choice for container orchestration offered by cloud providers.


Kubernetes: A Specification for Container Platforms


Kubernetes is an orchestration platform to run all of your containers. It allows developers and administrators to define the desired operational state of the system. Scaling policies within this configuration are of central importance. The Kubernetes controller ensures that the system adheres to the target state by changing the number of active container instances to meet usage demands. Further, container deployments are rolling, so no downtime occurs while changes are being made.

Auto-scaling policies can be set on a number of dimensions including CPU or memory. As an example, the following command configures the autoscaler to maintain a number of web application container instances that keep CPU utilization around 50% across the fleet, while staying within the bounds of 1 and 10 active instances. Note that kubectl is a command line interface to the Kubernetes controller.


kubectl autoscale deployment my-web-app –cpu-percent=50 –min=1 –max=10


Microservices architectures take full advantage of the Kubernetes platform. The container flexibility discussed earlier is put to use in this case as each service can be scaled separately. From an enterprise perspective, this is a critical enabler towards the goal of optimizing resource utilization, cost, and user responsiveness.


The Challenge Facing the Industry


As with most new technologies, there is a learning curve to overcome and migration planning that must occur with the shift to Kubernetes. The industry is still early in its adoption as it works through these challenges. According to the VMWare State of Kubernetes Report 2020, only 59% of respondents were running Kubernetes in production. This report polled organizations with fewer than 1,000 employees who indicated they were already using Kubernetes in some capacity. Of the respondents, 57% have fewer than ten clusters.

You might also like:   Up Your DevOps Game: Its Time for NoOps

Why is the adoption rate not higher? A critical statistic from this study may provide the answer. Of the organizations surveyed, 70% cited a lack of expertise and experience as a blocker. Containers and Kubernetes provide great benefits, but they come with a degree of complexity.

Consider even the definition of a container, which typically requires an entire paragraph to explain the full nuance behind the idea and its usage. This is where a PaaS such as EYK can dramatically accelerate your infrastructure’s evolution to leverage these technologies. You can gain the benefits of these patterns and technologies at a fraction of the cost.


NoOps using EngineYard Kontainers


How does NoOps eliminate the operational burden? It starts with turning deployments into a single command integrated within the developer workflow. The typical development life cycle involves making code changes, performing unit testing, and committing code to a configuration management repository such as Git. The git push command sends these updates to the central repository.

Using EYK, you create an application from your existing Git project. Deployment is then accomplished using the following similar command:


git push eyk <branch-name>


That’s it. That’s all there is to it.


The eyk remote target in Git is created when you define the EYK application. This push command sends the code to the EYK platform for deployment. Without any additional work by the developer, the code is packaged into a container and deployed on a fully-managed Kubernetes platform.

The platform incorporates all relevant best practices based on the expertise and experience of 10 years hosting full-stack Ruby-on-Rails applications. Monitoring is automatically put in place and containers are auto-scaled based on need and policy. Even the application logs are all easily viewed in one place. EYK is completely self-service, but if for any reason you need assistance, there is 24×7 customer support ready and available to help you.

The best part of this approach is that no code changes are required to leverage the platform. Industry-standard Docker files are used if you have special requirements for your runtime environment. Tools are provided to construct a Dockerfile if one is needed.

EYK truly brings NoOps to life. It provides a way for organizations both large and small to realize the benefits of DevOps, Container, and Kubernetes without the huge ramp up and resource investment. Start your free trial now at engineyard.com.

Want more posts like this?

What you should do now:


Easy Application Deployment to AWS

Focus on development, not on managing infrastructure

Deploying, running and managing your Ruby on Rails app is taking away precious resources? Engine Yard takes the operational overhead out of the equation, so you can keep innovating.

  • Fully-managed Ruby DevOps
  • Easy to use, Git Push deployment
  • Auto scaling, boost performance
  • Private, fully-configured Kubernetes cluster
  • Linear pricing that scales, no surprises
  • Decades of Ruby and AWS experience

14 day trial. No credit card required.

Sign Up for Engine Yard

14 day trial. No credit card required.

Book a Demo