{"id":769,"date":"2022-01-25T01:11:00","date_gmt":"2022-01-25T01:11:00","guid":{"rendered":"https:\/\/blog.ngocha.biz\/?p=769"},"modified":"2022-01-25T01:11:00","modified_gmt":"2022-01-25T01:11:00","slug":"what-is-docker","status":"publish","type":"post","link":"https:\/\/blog.ngocha.biz\/?p=769","title":{"rendered":"What is Docker? How Does it Work?"},"content":{"rendered":"

In this comprehensive guide, I have explained what is Docker, its evolution, underlying core Linux concepts, and how it works.<\/p>\n

Docker has become the defacto standard when it comes to container-based implementations. Docker is the base for container-based orchestration<\/a> from small-scale implementations to large-scale enterprise applications.<\/p>\n

Docker gained so much popularity and adoption in the DevOps community quickly because it’s developed for portability and designed for modern microservice architecture.<\/p>\n

In this blog, you will learn,<\/p>\n

    \n
  1. What is Docker?<\/li>\n
  2. Learn about Docker and see why Docker is beneficial and different from other container technologies.<\/li>\n
  3. Docker core architecture and its key components<\/li>\n
  4. Container evolution and the underlying concept of Linux Containers<\/li>\n
  5. What is a container, and what Linux features make it work?<\/li>\n
  6. The difference between a process, container, and a VM<\/li>\n<\/ol>\n

    Here, the idea is to get your basics right to understand what Docker really is and how it works.<\/p>\n

    What is Docker?<\/h2>\n

    Docker is a popular open-source project written in go and developed by Dotcloud (A PaaS Company).<\/p>\n

    It is a container engine that uses the Linux Kernel features<\/strong> like namespaces and control groups to create containers on top of an operating system. So you can call it OS-level virtualization.<\/p>\n

    Docker was initially built on top of Linux containers (LXC<\/strong><\/a>)<\/strong>. Later Docker replaced LXC with its container runtime libcontainer (now part of runc<\/a>). I have explained the core LXC & container concepts towards the end of the article.<\/p>\n

    You might ask how Docker is different from a Linux Container (LXC) as all the concepts and implementation look similar?<\/p>\n

    Besides just being a container technology, Docker has well-defined wrapper components that make packaging applications easy<\/strong>. Before Docker, it was not easy to run containers. Meaning it does all the work to decouple your application from the infrastructure by packing all application system requirements into a container.<\/p>\n

    For example, if you have a Java jar file, you can run it on any server which has java installed. Same way, once you package a container with required applications using Docker, you can run it on any other host which has Docker installed.<\/p>\n

    We will have containers up and running by executing a few Docker commands & parameters.<\/p>\n

    Difference Between Docker & Container<\/h3>\n

    Docker is a technology or a tool developed to manage containers efficiently.<\/p>\n

    So, can I run a container without Docker?<\/p>\n

    Yes! of course. You can use LXC technology to run containers on Linux servers. In addition, the latest tools like Podman<\/a> offers similar workflows like Docker.<\/p>\n

    Things you should know about Docker:<\/h4>\n
      \n
    1. Docker is not LXC<\/li>\n
    2. Docker is not a Virtual Machine Solution.<\/li>\n
    3. Docker is not a configuration management system and is not a replacement for Chef, Puppet, Ansible, etc.<\/li>\n
    4. Docker is not a platform as a service technology.<\/li>\n
    5. Docker is not a container.<\/li>\n<\/ol>\n

      What Makes Docker So Great?<\/h2>\n

      Docker has an efficient workflow for moving the application from the developer’s laptop to the test environment to production. You will understand more about it when you look at a practical example of packaging an application into a Docker image.<\/p>\n

      Do you know that starting a docker container takes less than a second<\/strong>?<\/p>\n

      It is incredibly fast, and it can run on any host with compatible Linux Kernel. (Supports Windows as well)<\/p>\n

      \n
      Note:<\/strong><\/b> you cannot run a Windows container on a Linux host because there is no Linux Kernel support for Windows. You can read about Windows containers from here<\/a><\/div>\n<\/div>\n

      Docker uses a Copy-on-write union file system<\/a> for its image storage. Therefore, when changes are made to a container, only the changes will be written to disk using copy on the write model.<\/p>\n

      With Copy on write<\/a>, you will have optimized shared storage layers for all your containers.<\/p>\n

      Docker Adoption Statistics<\/h2>\n

      Here is the google trends data on Docker. You can see it has been an exploding topic for the last five years.<\/p>\n

      \"\"<\/figure>\n

      Here is a survey result from Datadog, which shows the rise in Docker adoption.<\/p>\n

      \"\"
      source: <\/span>datadog.com<\/span><\/a><\/figcaption><\/figure>\n

      Docker Core Architecture<\/h2>\n

      The following sections will look at the Docker architecture and its associated components. We will also look at how each component works together to make Docker work.<\/p>\n

      Docker architecture has changed a few times since its inception. When I published the first version of this article, Docker was built on top of LXC<\/p>\n

      Here are some notable architectural changes that happened for the Docker<\/p>\n

        \n
      1. Docker moved from LXC to libcontainer in 2014<\/li>\n
      2. runc<\/a> – a CLI for spinning up containers that follow all OCI specifications.<\/li>\n
      3. containerd<\/a> – Docker separated its container management component to containerd in 2016<\/li>\n<\/ol>\n
        \n
        OCI: Open Container Initiative<\/a> is an open industry standard for container runtime and specifications.<\/div>\n<\/div>\n

        When Docker was initially launched, it had a monolithic architecture. Now it is separated into the following three different components.<\/p>\n

          \n
        1. Docker Engine (dockerd)<\/li>\n
        2. docker-containerd (containerd)<\/li>\n
        3. docker-runc (runc)<\/li>\n<\/ol>\n

          Docker and other big organizations contributed to a standard container runtime and management layers. Hence containerd<\/code> and runc<\/code> are now part of the Cloud Native Foundation with contributors from all the organizations.<\/p>\n

          \n
          Note:<\/strong><\/b> When installing Docker<\/a>, all these components get installed. You don’t have to install it separately. For exaplanation, we are showing it as different components.<\/div>\n<\/div>\n
          \"docker
          Click to view in HD<\/span><\/figcaption><\/figure>\n

          Now let’s have a looks at each Docker component.<\/p>\n

          Docker Engine<\/h3>\n

          Docker engine comprises the docker daemon, an API interface, and Docker CLI. Docker daemon (dockerd) runs continuously as dockerd<\/code> systemd service. It is responsible for building the docker images.<\/p>\n

          To manage images and run containers, dockerd<\/code> calls the docker-containerd<\/code> APIs.<\/p>\n

          \"\"
          Click to view in HD<\/span><\/figcaption><\/figure>\n

          docker-containerd (containerd)<\/h3>\n

          containerd<\/code> is another system daemon service than is responsible for downloading the docker images and running them as a container. It exposes its API to receive instructions from the dockerd<\/code> service<\/p>\n

          docker-runc<\/h3>\n

          runc<\/code> is the container runtime responsible for creating the namespaces and cgroups required for a container. It then runs the container commands inside those namespaces. runc runtime is implemented as per the OCI specification.<\/p>\n

          Read this excellent 3 part blog post series<\/a> to understand more about container runtimes.<\/p>\n

          How Does Docker Work?<\/h2>\n

          We have seen the core building blocks of Docker.<\/p>\n

          Now let’s understand the Docker workflow using the Docker components.<\/p>\n

          Docker Components<\/h3>\n

          The following official high-level docker architecture<\/strong> diagram shows the common Docker workflow.<\/p>\n

          \"\"
          image source: <\/span>docs.docker.com<\/span><\/a><\/figcaption><\/figure>\n

          Docker ecosystem is composed of the following four components<\/p>\n

            \n
          1. Docker Daemon (dockerd)<\/li>\n
          2. Docker Client<\/li>\n
          3. Docker Images<\/li>\n
          4. Docker Registries<\/li>\n
          5. Docker Containers<\/li>\n<\/ol>\n

            What is a Docker Daemon?<\/h3>\n

            Docker has a client-server architecture. Docker Daemon (dockerd<\/code>) or server is responsible for all the actions related to containers.<\/p>\n

            The daemon receives the commands from the Docker client through CLI or REST API. Docker client can be on the same host as a daemon or present on any other host.<\/p>\n

            By default, the docker daemon listens to the docker.sock<\/code> UNIX socket. If you have any use case to access the docker API remotely, you need to expose it over a host port. One such use case is running Docker as Jenkins agents<\/a>.<\/p>\n

            If you want to run Docker inside Docker<\/a>, you can use the docker.sock<\/code> from the host machine.<\/p>\n

            What is a Docker Image?<\/h3>\n

            Images are the basic building blocks of Docker. It contains the OS libraries, dependencies, and tools to run an application.<\/p>\n

            Images can be prebuilt with application dependencies for creating containers. For example, if you want to run an Nginx web server as a Ubuntu container, you need to create a Docker image with the Nginx binary and all the OS libraries required to run Nginx.<\/p>\n

            What is a Dockerfile?<\/h3>\n

            Docker has a concept of Dockerfile<\/code> that is used for building the image. A Dockerfile a text file that contains one command (instructions) per line.<\/p>\n

            Here is an example of a Dockerfile.<\/p>\n

            \"example<\/figure>\n

            A docker image is organized in a layered fashion. Every instruction on a Dockerfile<\/code> is added a layer in an image. The topmost writable layer of the image is a container.<\/p>\n

            Every image is created from a base image.<\/p>\n

            For example, if you can use a base image of Ubuntu and create another image with the Nginx application. A base image can be a parent image or an image built from a parent image. Check out his docker article<\/a> to know more about it.<\/p>\n

            You might ask where this base image (Parent image) comes from? There are docker utilities to create the initial parent base image. It takes the required OS libraries and bakes them into a base image. You don’t have to do this because you will get the official base images for Linux distros.<\/p>\n

            \"Docker<\/figure>\n

            The top layer of an image is writable and used by the running container. Other layers in the image are read-only.<\/p>\n

            \"Docker<\/figure>\n

            What is a Docker Registry?<\/h3>\n

            It is a repository (storage) for Docker images.<\/p>\n

            A registry can be public or private. For example, Docker Inc provides a hosted registry service called Docker Hub. It allows you to upload and download images from a central location.<\/p>\n

            \n
            Note:<\/strong><\/b> By default, when you install docker, it looks for images from the public Docker hub unless you specify a custom registry in Docker settings.<\/div>\n<\/div>\n

            Other Docker hub users can access all your images if your repository is public. You can also create a private registry in Docker Hub.<\/p>\n

            Docker hub acts like git, where you can build your images locally on your laptop, commit it, and then be pushed to the Docker hub.<\/p>\n

            \n
            Tip:<\/strong><\/b> When using docker in enterprise networks\/project, set up your own docker registries instead of using the public docker hub. All cloud providers have their own container registry services.<\/div>\n<\/div>\n

            What is a Docker Container?<\/h3>\n

            Docker Containers are created from existing images. It is a writable layer of the image.<\/p>\n

            If you try to relate image layers and a container, here is how it looks for a ubuntu-based image.<\/p>\n

            \"Pictorial
            source: <\/span>docs.docker.com<\/span><\/a><\/figcaption><\/figure>\n

            You can package your applications in a container, commit it, and make it a golden image to build more containers from it.<\/p>\n

            Containers can be started, stopped, committed, and terminated. If you terminate a container without committing it, all the container changes will be lost.<\/p>\n

            Ideally, containers are treated as immutable objects, and it is not recommended to make changes to a running container. Instead, make changes to a running container only for testing purposes.<\/p>\n

            Two or more containers can be linked together to form tiered application architecture. However, hosting hight scalable applications with Docker has been made easy with the advent of container orchestration tools<\/a> like kubernetes<\/a>.<\/p>\n

            Docker FAQs<\/h2>\n

            What is the difference between containerd & runc?<\/h2>\n

            Containerd is responsible for managing the container and runc is responsible for running the containers (create namespaces, cgroups and run commands inside the container) with the inputs from containerd<\/p>\n

            What is the difference between the Docker engine & the Docker daemon?<\/h3>\n

            Docker engine is composed of the docker daemon, rest interface, and the docker CLI. Docker daemon is the systemd dockerd service responsible for building the docker images and sending docker instructions to containerd runtime.<\/p>\n

            Conclusion<\/h2>\n

            By now, you should have a good understanding of what Docker is and how it works.<\/p>\n

            The best feature of Docker is collaboration. Docker images can be pushed to a repository and pulled down to any other host to run containers from that image.<\/p>\n

            Moreover, the Docker hub has thousands of images created by users, and you can pull those images down to your hosts based on your application requirements. Also, it is primarily used in container orchestration tools like kubernetes<\/p>\n

            Go ahead and install Docker<\/a> and then you can start building your own docker images. Check out the comprehensive build docker image<\/a> guide to deploy your first container.<\/p>\n

            If you want to run Docker for production workloads, make sure you follow Docker images’ recommended practices.<\/p>\n

            You can read my article on how to reduce docker image size<\/a> where I have listed down all the standard approaches to optimize the docker image.<\/p>\n

            Also, if you are trying to become a DevOps engineer<\/a>, I highly recommend you get hands-on experience with Docker.<\/p>\n

            \n

            Ngu\u1ed3n:<\/strong> What is Docker? How Does it Work? \u2014 DevOpsCube<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

            Source: https:\/\/devopscube.com\/what-is-docker\/<\/p>\n","protected":false},"author":1,"featured_media":770,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-769","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-devops"],"_links":{"self":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts\/769","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=769"}],"version-history":[{"count":0,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts\/769\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/media\/770"}],"wp:attachment":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=769"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=769"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=769"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}