Demystifying containers, Docker, and Kubernetes


Modern application infrastructure is being transformed by containers. The question is: How do you get started?
Understanding what problems containers, Docker, and Kubernetes solve is essential if you want to build modern cloud-native apps or if you want to modernize your existing legacy applications. In this post, we’ll go through what they are and how you can learn more to advance to the next level.
What are containers?
Containers effectively virtualize the host operating system (or kernel) and isolate an application’s dependencies from other containers running on the same machine. Before containers, if you had multiple applications deployed on the same virtual machine (VM), any changes to shared dependencies could cause strange things to happen—so the tendency was to have one application per virtual machine.
The solution of one application per VM solved the isolation problem for conflicting dependencies, but it wasted a lot of resources (CPU and memory). This is because a VM runs not only your application but also a full operating system that needs resources too, so less would be available for your application to use.
Containers solve this problem with two pieces: a container engine and a container image, which is a package of an application and its dependencies. The container engine runs applications in containers isolating it from other applications running on the host machine. This removes the need to run a separate operating system for each application, allowing for higher resource utilization and lower costs.
Diagram of VM and container stacks
If you want to learn more about containers, watch this short video on why you should care about containers.
What is Docker?
Docker was first released in 2013 and is responsible for revolutionizing container technology by providing a toolset to easily create container images of applications. The underlying concept has been around longer than Docker’s technology, but it was not easy to do until Docker came out with its cohesive set of tools to accomplish it. Docker consists of a few components: a container runtime (called dockerd), a container image builder (BuildKit), and a CLI that is used to work with the builder, containers, and the engine (called docker).
Docker images vs. Docker containers
A Docker image is a template; a Docker container is a running instance of that template.
To create an image with your application’s source code, you specify a list of commands in a special text file named Dockerfile. The docker builder takes this file and packages it into an image. Once you have an image, you push it to a container registry—a central repository for versioning your images.
When you want to run a Docker image, you need to either build it or pull the image from a registry. DockerHub is a well-known public registry, but there are also private registries like Azure Container Registry that allow you to keep your application images private.
If you want a hands-on example, this is a good great resource: Deploy Python using Docker containers.

What is Kubernetes?
Kubernetes is an open-source container management platform that unifies a cluster of machines into a single pool of compute resources. With Kubernetes, you organize your applications in groups of containers, which it runs using the Docker engine, taking care of keeping your application running as you request.
Kubernetes provides the following:
Compute scheduling—It considers the resource needs of your containers, to find the right place to run them automatically
Self-healing—If a container crashes, a new one will be created to replace it.
Horizontal scaling—By observing CPU or custom metrics, Kubernetes can add and remove instances as needed.
Volume management—It manages the persistent storage used by your applications
Service discovery & load balancing—IP address, DNS, and multiple instances are load-balanced.
Automated rollouts & rollbacks–During updates, the health of your new instances are monitored, and if a failure occurs, it can roll back to the previous version automatically.
Secret & configuration management. It manages application configuration and secrets.
Kubernetes uses a master/slave communication model where there is at least one master and usually several worker nodes. The master (sometimes called the control plane) has three components and a data store:
API server—exposes the Kubernetes API for controlling the cluster
Controller manager—responsible for watching the cluster’s objects and resources and ensuring the desired state is consistent
Scheduler—responsible for scheduling compute requests on the cluster
etcd—an open-source distributed key value store used to hold the cluster data
The worker nodes provide the container runtime for your applications and have a few components responsible for communicating with the master and networking on every worker node:
Kubelet—responsible for communicating to the master and ensuring the containers are running on the node
Kube-proxy—enables the cluster to forward traffic to executing containers
Docker (container runtime)—provides the runtime environment for containers
Diagram showing Kubernetes master and worker nodes
The master and workers are the platform that run your applications. In order to get your applications running on the cluster, you need to interact with the API server and work with the Kubernetes object model.
Kubernetes objects
To run an application on Kubernetes, you need to communicate with the API server using the object model. The objects are usually expressed in .yaml or .json format; kubectl is the command-line interface used to interact with the API.
The most common objects are:
Pod—a group of one or more containers and metadata
Service—works with a set of pods and directs traffic to them
Deployment—ensures the desired state and scale are maintained
To find out more about how your applications work on Kubernetes, watch this short video by Brendan Burns on How Kubernetes works.
Here is a great walkthough that uses a Python voting application and a Redis cache to help you get started with the Kubernetes concepts.
Conclusion
Containers are the foundation of modern applications. Docker provides the toolset to easily create container images of your applications, and Kubernetes gives you the platform to run it all.
Now that you know the basic pieces of the puzzle and have a better idea of what containers, Docker, and Kubernetes are all about, you can learn more at Kubernetes Learning Path.[Source]-https://cloudblogs.microsoft.com/opensource/2019/07/15/how-to-get-started-containers-docker-kubernetes/
Beginners & Advanced level Docker Training Course in Mumbai. Asterix Solution's 25 Hour Docker Training gives broad hands-on practicals.


Comments

Post a Comment

Popular posts from this blog

Why, when and how to return Stream from your Java API instead of a collection

Introduction Collections are basic and commonly used data structures. Programmers from the beginning of their career learn how to use them to receive, process and return data. Getting more advanced in Java programming, they find stream() method to convert a collection into a stream and learn how to process data using some of the stream’s useful methods like map, flatMap or reduce. They could also notice that other APIs in Java return a stream too e.g. String.lines(), Matcher.results(), Files.find(), Random.ints(). If you have experience with consuming streams but haven’t produced them yet, this article is for you. I’m going to show you some scenarios where streams can be very convenient and examples on how to use them. Additionally, I shortly mention error handling and resource management. The article is based on standard Java library java.util.stream. It’s related neither to reactive streams nor to other implementation of streams like e.g. Vavr. Also, I’m not going to cover a...
Read more

What is Kubernetes?

Kubernetes (also known as k8s or “kube”) is an open source container orchestration platform that automates many of the manual processes involved in deploying, managing, and scaling containerized applications. In other words, you can cluster together groups of hosts running Linux containers, and Kubernetes helps you easily and efficiently manage those clusters. Kubernetes clusters can span hosts across on-premise, public, private, or hybrid clouds. For this reason, Kubernetes is an ideal platform for hosting cloud-native applications that require rapid scaling, like real-time data streaming through Apache Kafka. Kubernetes was originally developed and designed by engineers at Google. Google was one of the early contributors to Linux container technology and has talked publicly about how everything at Google runs in containers. (This is the technology behind Google’s cloud services.) Google generates more than 2 billion container deployments a week, all powered by its ...
Read more

Best way to learn Java programming

Having said that I am writing this post dedicated to all my young (or I should say beginner) fellows who want to attain a certain level of proficiency in java technology and somewhere would like to take my advice on this. Keep in mind that if you do not like the way to learn java, I am proposing in this post, then just ignore me. Period. OR better, suggest me what you think is the better way to learn java fast or easily. Here I am assuming the people reading this post will be, who are very new to language, so I will start by listing first thing first. Make sure you have prepared your Java development environment ready i.e. You have installed JDK/JRE and you have an IDE like Eclipse. 1) Learn the language basics This is the first step for very obvious reason. If you don’t know the basics then you will never know either what to do next or what you are doing wrong. Initially, I do not expect from you to become the master of all java basic stuffs like keywords, core concepts o...
Read more