As a new engineer, understanding the concept of containerization is important for several reasons.
First, containerization is a key component of cloud native application development. Containers are a lightweight and portable way to package software, making it easy to run and manage applications on cloud infrastructure. By understanding how containers work, you will be able to build, deploy, and manage cloud-native applications more effectively.
Second, containerization allows for greater consistency and portability across different environments. With containers, you can package an application and its dependencies together, ensuring that it will run the same way regardless of where it is deployed. This eliminates the “works on my machine” problem and makes it easier to move applications between different environments.
Third, containerization allows for greater scalability and resource efficiency. Containers use less resources than traditional virtual machines, and can be easily scaled up or down as needed. This makes it easier to handle the increasing demand for more computing power and storage.
Fourth, containerization also allows for better collaboration and DevOps culture, as containers can be easily shared and reused, making it easier for different teams and developers to work together on the same application.
In summary, as a new engineer, understanding the concept of containerization is important because it is a key component of cloud native application development, allows for greater consistency and portability across different environments, enables greater scalability and resource efficiency, and promotes collaboration and DevOps culture. It is a powerful tool for building and deploying applications in a cloud environment and is essential for any engineer working in the field today.
Here’s a list to get you started learning about containerization. Note that some of these links may not be free and may require a subscription or payment. I receive no affiliate payments for these links.
- “Introduction to Containers, Kubernetes, and OpenShift” by Coursera: https://www.coursera.org/learn/ibm-containers-docker-kubernetes-openshift
- “Docker 101” by Docker: https://www.docker.com/101-tutorial/
- “Introduction to Containers: Basics of Containerization” by Animesh Gaitonde: https://medium.com/geekculture/introduction-to-containers-basics-of-containerization-bb60503df931
- “Docker Mastery with Kubernetes +Swarm from a Docker Captain” by Bret Fisher: https://www.bretfisher.net/docker-mastery/
- “Kubernetes Basics” by Kubernetes: https://kubernetes.io/docs/tutorials/kubernetes-basics/
- “Docker and Kubernetes: The Complete Guide” by Udemy: https://www.udemy.com/course/docker-and-kubernetes-the-complete-guide/
- “Learn DevOps: Advanced Kubernetes Usage” by Udemy: https://www.udemy.com/course/learn-devops-advanced-kubernetes-usage/
- “Docker Deep Dive” by Nigel Poulton: https://www.amazon.com/Docker-Deep-Dive-Nigel-Poulton-ebook/dp/B01LXWQUFF
- “Kubernetes in Production Best Practices” by O’Reilly: https://learning.oreilly.com/library/view/kubernetes-in-production/9781800202450/
Videos to Watch
Kubernetes Crash Course for Absolute Beginners
Kubernetes is an open source container orchestration framework designed to manage applications made up of hundreds or thousands of containers across multiple environments. It offers features such as high availability, scalability, and disaster recovery, as well as a virtual network that enables communication between pods. This video provides an overview of the Kubernetes architecture and components, and a use case of a web application with a database to illustrate how it works.
Possible Learning Path
Hands-on experience: Start by installing Docker and Kubernetes on your local machine or in a virtual environment. This can be done by following the official documentation provided by Docker and Kubernetes. After that, you can follow tutorials and guides to build and deploy simple applications in containers using Docker and Kubernetes.
Theoretical learning: Once you have a basic understanding of Docker and Kubernetes, you can begin to explore the underlying concepts and technologies. This can be done through online resources such as tutorials, courses, and documentation provided by Docker and Kubernetes, as well as books and blogs on the topic.
Joining a community: Joining a community of Docker and Kubernetes enthusiasts will help you connect with other people who are learning and working with these technologies. This can be done through online forums, meetups, and social media groups.
Practice, practice, practice: As with any new technology, the best way to learn is by doing. The more you practice building and deploying containerized applications using Docker and Kubernetes, the more comfortable and proficient you will become with these technologies.
Specialize in a specific use case: Docker and Kubernetes can be used in a wide variety of scenarios and use cases, so it is beneficial to specialize in one or two that align with your business or career goals.
A Note from the Architect
I’m trying to think of the first time I worked with a Docker container. I believe it was almost four years ago, which in technology timeframes was forever. I was trying to decide if I wanted to use Angular or React to create components for a plugin framework running on SharePoint. It wasn’t the type of development I was used to doing at the time, but I knew the industry was heading away from Angular and more toward React. So, I installed Docker on my laptop, learned how to check out the images, and eventually started learning the basics of containers. I was hooked. Here was a great way to build apps, host them locally, and get the same experience locally that I could expect in production. No more, “It worked on my machine.”
In the last couple of years, I’ve used the remote connection capabilities of VS Code to run pretty much all of my development in containers. It gives me the freedom to try out different languages, frameworks, and libraries without ever needing to install those on my local operating system. I’m proud to say that I never get bugged for Java or .Net updates now. I just get the latest images and add a volume that connects to a local folder where I manage my Git repositories. It’s made my life as a developer much easier.
If you’re wondering, “What’s the big deal with containers? I just want to write code. Why do I need to use containers?” I’ll try to answer that question. Because we don’t just write code anymore. As developers and as operations engineers, we’re beginning to move into a phase where we are sharing the overall solution. This means that when I create something or have a hand in creating something, I have ownership over that thing. I’m responsible for it.
Now, you might work for an enterprise that’s still a bit behind the times. You may write code, and some other team might test that code, and then some other team might try to deploy that code. In that situation, you probably aren’t using containers or anything that looks like modern DevOps. And in that situation, the team between you and the customers who will derive value from your code is a bottleneck. If you rely on a QA team, they will find bugs, because that’s what they are incentivized to do. It’s their job to compare your code against some form of requirements and fail it if it doesn’t meet those requirements. Operations in this type of environment is incentivized to keep systems running smoothly, so they’ll look for any excuse to deny your code entry into production—that usually looks like a set of meetings designed to make sure you met all the criteria needed for something to go into production.
That is the old way of developing software. Let me tell you, if you’re working some place like that, get out. No. Seriously. Leave. Find a better job.
I believe this is the way software should be developed:
In an ideal software development process, the only work done is understanding the problem, writing code to solve it, testing to confirm it is solved, and making progress in small steps to retain the ability to change the system when needed. The goal is to minimize work and maximize learning, allowing for changes to be made easily and with confidence.
Containers make this process easier. Your code remains modular, making it easier to version and manage libraries and dependencies. You can even build out the needed infrastructure for a container management system, such as Kubernetes, without involving operations in some cases.
As a developer and an architect, I have found that containers have improved the quality of my development life. They have allowed me to have more control over the solutions I deliver. I believe that if you start working regularly with containers, you will feel the same way too.