Docker: Difference between revisions

Revision as of 17:42, 6 July 2025

Docker is an open-source platform that automates the deployment, scaling, and management of applications within lightweight, portable containers. It leverages containerization technology to allow developers to package applications and their dependencies into a standardized unit called a container. This encapsulation provides numerous benefits, including consistency across different computing environments, ease of deployment, and improved resource utilization.

History

Docker was initially developed by Solomon Hykes as an internal project at dotCloud, a platform-as-a-service company, in 2010. The first release of Docker was in March 2013, with the core idea revolving around simplifying the deployment process and creating standardized environments for applications. The project quickly gained immense popularity due to its ability to solve many problems associated with traditional virtualization, such as resource overhead and deployment complexity.

By 2014, Docker had transitioned into a standalone company, with Hykes serving as its CTO. The expansion of Docker's functionality continued, leading to the introduction of Docker Compose for defining multi-container applications in a declarative manner, and Docker Swarm for orchestrating clusters of Docker containers. As the community grew, Docker began to adopt and promote standards for container images, and in 2015, the Open Container Initiative (OCI) was formed to establish common standards for container formats and runtimes.

As of 2023, Docker has established itself as a cornerstone of modern software development practices, particularly in the realms of DevOps and microservices architecture. It has been instrumental in the adoption of Continuous Integration and Continuous Deployment (CI/CD) pipelines across various industries.

Architecture

Docker’s architecture is typically composed of three primary components: the Docker daemon, Docker client, and Docker registry. Each of these plays a crucial role in the overall functioning of the platform.

Docker Daemon

The Docker daemon, also referred to as `dockerd`, is responsible for managing Docker containers. It handles all interactions with containers, images, networks, and volumes. The daemon listens for API requests from the Docker client and runs as a background process on the host operating system. It is critical for handling the lifecycle of containers, which includes creating, starting, stopping, and deleting them. The daemon can also communicate with other Docker daemons to manage multi-host container deployment and orchestration.

Docker Client

The Docker client is the primary interface through which users interact with Docker. It can be run from a command-line interface or via graphical interfaces provided by third-party tools. The client communicates with the Docker daemon using the Docker API, allowing users to execute commands such as `docker run`, `docker pull`, and `docker build`. The client can be run on the same host as the daemon or on remote systems, facilitating remote management of Docker containers.

Docker Registry

Docker Registry is a storage and distribution system for Docker images. When a user builds an image, they can push it to a registry for storage and later retrieval. The most widely used public registry is Docker Hub, which hosts a vast collection of pre-built images available for use. Organizations can also set up private registries to store proprietary images securely. Docker registries enable version control and sharing of container images efficiently across teams and environments.

Implementation

The implementation of Docker is made simple through its command-line interface and various APIs, allowing for straightforward integration into existing workflows. The combination of Docker Engine, CLI tools, and various orchestration frameworks allows developers to create, manage, and scale containerized applications easily.

Installing Docker

Docker can be installed on various operating systems, including Linux, macOS, and Windows. The installation process may differ slightly depending on the host OS. Typically, users download the Docker Desktop application or install the Docker Engine using package management systems available for their operating systems. Following installation, users can verify the setup by running the `docker --version` command to confirm that Docker is functioning as expected.

Creating Container Images

Creating container images involves writing a `Dockerfile`, which contains a set of instructions for building an image. Instructions typically specify a base image, required files, environment variables, and command execution. Once the `Dockerfile` is defined, users can build images using the `docker build` command, specifying the Docker context from which the image will be built. The resulting images can then be run as containers.

Running Containers

Running containers is achieved with the `docker run` command, which allows users to execute a container from a specified image. The command supports various options to manage the container's behavior, such as mapping ports, mounting volumes, and assigning environment variables. Once a container is launched, it can be accessed through specified ports or integrated with other services.

Orchestration and Scaling

While Docker makes it easy to create and run containers, managing a large number of containers across different hosts can be challenging. To address this, Docker Swarm and Kubernetes emerged as popular orchestration tools.

Docker Swarm is integrated directly into the Docker Engine, allowing users to set up a cluster of Docker nodes and deploy scaled applications across them. Swarm mode introduces concepts such as services, replicas, and load balancing, making distributed applications easier to manage.

Kubernetes, on the other hand, is an open-source container orchestration platform that provides a more extensive set of features. Although initially developed by Google, it has become a widely adopted standard for orchestrating containerized applications. Kubernetes supports scaling, self-healing, service discovery, and rolling updates, making it a popular choice for managing container workloads in production environments.

Applications

Docker has found widespread applications across various sectors and in numerous development strategies. Organizations leverage Docker to simplify and accelerate their software development processes. Some of the most common applications include:

Microservices Architecture

In a microservices architecture, applications are broken down into smaller, independent services that can be developed, deployed, and scaled independently. Docker is particularly well-suited to this approach, as it allows developers to encapsulate each microservice in its own container, ensuring that dependencies and configurations are isolated. This practice enhances the agility of development teams, enabling faster iterations and more manageable deployments.

Continuous Integration/Continuous Deployment (CI/CD)

Docker plays a crucial role in CI/CD pipelines by providing a consistent environment for build, testing, and deployment phases. CI/CD tools such as Jenkins, GitLab CI/CD, and CircleCI integrate seamlessly with Docker, allowing automated testing of containerized applications. This consistency ensures that applications behave the same in development, testing, and production environments, thus reducing "it works on my machine" issues. By utilizing Docker, developers can streamline the release process and quickly deliver new features and fixes to users.

Development and Testing Environments

Docker significantly eases the process of setting up development and testing environments. Developers can create containers that mirror the production environment closely, leading to more reliable testing outcomes. They can quickly spin up or tear down instances of services and applications, allowing for experimentation without risking changes to the underlying infrastructure.

Hybrid and Multi-cloud Deployments

Docker's portability allows organizations to deploy applications across various cloud providers or hybrid environments seamlessly. As a result, organizations can avoid vendor lock-in, utilizing the best features offered by different platforms. For instance, a company could deploy its application on both AWS and Google Cloud based on specific requirements, benefiting from the elasticity and scalability of both platforms.

Criticism and Limitations

Despite its myriad advantages, Docker has faced some criticism and limitations that have been debated within the tech community.

Security Concerns

One major criticism of Docker stems from security. Given that containers share the host OS kernel, a vulnerability in one container can potentially impact others. Therefore, application isolation is less stringent compared to traditional virtual machines. Although improvements have been made in container security, such as the introduction of user namespaces and security profiles, organizations must implement strict policies and practices, routinely scanning images for vulnerabilities and ensuring that containers run with the least privilege principle.

Complexity and Learning Curve

Novice users may encounter a steep learning curve when adopting Docker, especially when integrating it with other tools and workflows. Understanding how Docker containers work, how to write effective `Dockerfile` scripts, and navigating orchestration tools can be demanding. Furthermore, teams accustomed to monolithic application architectures may find it challenging to adapt to the microservices paradigm and the associated complexities.

Resource Overhead

While containers are generally more lightweight than traditional virtual machines, they still consume resources on the host machine. Running many containers on a single host can lead to resource contention, especially if not adequately managed. Organizations must monitor resource usage and apply limits on CPU and memory consumption for individual containers to maintain optimal performance.

Real-world Examples

Many organizations, from startups to Fortune 500 companies, leverage Docker to enhance their development and deployment processes. A few notable examples include:

Google

Google adopted containerization early on and developed Kubernetes, which has become the industry standard for orchestrating Docker containers. Google itself utilizes Docker to manage its internal applications and services, benefiting from the scalability and portability that containerization offers.

Netflix

Netflix uses Docker to manage its microservices architecture, enabling the company to deploy thousands of microservices at scale. The ability to consistently and reliably deploy applications in transient environments has been pivotal in maintaining Netflix's seamless streaming service.

IBM

IBM has integrated Docker into its services and offerings, promoting hybrid cloud environments that utilize containerization. Docker provides IBM clients with flexibility and consistency for their applications, especially when transitioning between on-premise and cloud environments.

References

@@ Line 1: / Line 1: @@
-'''Docker''' is an open-source platform that automates the deployment, scaling, and management of applications within lightweight containers. These containers encapsulate an application and its dependencies, allowing it to run consistently across different environments. Developed by Solomon Hykes and released in 2013, Docker revolutionized the software development and deployment processes by allowing developers to ship applications quickly and with confidence. The technology is built on a client-server architecture and leverages the capabilities of containerization to enhance the efficiency and agility of modern software development.
+'''Docker''' is an open-source platform that automates the deployment, scaling, and management of applications within lightweight, portable containers. It leverages containerization technology to allow developers to package applications and their dependencies into a standardized unit called a container. This encapsulation provides numerous benefits, including consistency across different computing environments, ease of deployment, and improved resource utilization.
 == History ==
-=== Origins ===
+Docker was initially developed by Solomon Hykes as an internal project at dotCloud, a platform-as-a-service company, in 2010. The first release of Docker was in March 2013, with the core idea revolving around simplifying the deployment process and creating standardized environments for applications. The project quickly gained immense popularity due to its ability to solve many problems associated with traditional virtualization, such as resource overhead and deployment complexity.
-Docker originated from the concept of container-based virtualization. The idea of containers dates back to the 1970s, but it gained significant popularity with the advent of Linux and its cgroups and namespaces features in the early 2000s. The evolution of these features paved the way for the creation of isolated environments that could be used to package applications along with their dependencies.
-In 2010, when Solomon Hykes was working on an internal project called "dotCloud," he developed an open-source project named "Docker." The project aimed to simplify the process of deploying and managing applications by allowing developers to package applications into containers that could run on any computing environment. In March 2013, Docker was released to the public, becoming a groundbreaking tool for developers and system administrators.
+By 2014, Docker had transitioned into a standalone company, with Hykes serving as its CTO. The expansion of Docker's functionality continued, leading to the introduction of Docker Compose for defining multi-container applications in a declarative manner, and Docker Swarm for orchestrating clusters of Docker containers. As the community grew, Docker began to adopt and promote standards for container images, and in 2015, the Open Container Initiative (OCI) was formed to establish common standards for container formats and runtimes.
-=== Growth and Ecosystem ===
+As of 2023, Docker has established itself as a cornerstone of modern software development practices, particularly in the realms of DevOps and microservices architecture. It has been instrumental in the adoption of Continuous Integration and Continuous Deployment (CI/CD) pipelines across various industries.
-Docker quickly gained adoption due to its innovative approach toward application deployment. The growing developer community contributed to a vibrant ecosystem surrounding Docker, which led to an abundance of tools and services focused on containerization. In June 2014, Docker, Inc. was founded to further develop the technology and support its user base.
-The introduction of Docker Hub, a cloud-based repository for sharing and distributing container images, facilitated the widespread use of Docker containers and encouraged collaboration in the development community. The creation of the Open Container Initiative (OCI) in 2015 aided in standardizing container formats, ensuring compatibility across various container systems. By 2020, Docker had evolved into a key player in the cloud-native ecosystem, with enterprises adopting containerization as a core element of their software development practices.
+== Architecture ==
+Docker’s architecture is typically composed of three primary components: the Docker daemon, Docker client, and Docker registry. Each of these plays a crucial role in the overall functioning of the platform.
+=== Docker Daemon ===
-== Architecture ==
+The Docker daemon, also referred to as `dockerd`, is responsible for managing Docker containers. It handles all interactions with containers, images, networks, and volumes. The daemon listens for API requests from the Docker client and runs as a background process on the host operating system. It is critical for handling the lifecycle of containers, which includes creating, starting, stopping, and deleting them. The daemon can also communicate with other Docker daemons to manage multi-host container deployment and orchestration.
+=== Docker Client ===
-=== Core Components ===
+The Docker client is the primary interface through which users interact with Docker. It can be run from a command-line interface or via graphical interfaces provided by third-party tools. The client communicates with the Docker daemon using the Docker API, allowing users to execute commands such as `docker run`, `docker pull`, and `docker build`. The client can be run on the same host as the daemon or on remote systems, facilitating remote management of Docker containers.
-The architecture of Docker is based on a client-server model that consists of the following primary components:
-* '''Docker Client''': The Docker client is the primary interface that users interact with. It allows users to issue commands to manage Docker containers, images, networks, and volumes. The Docker client communicates with the Docker daemon through a REST API, which can be accessed through the command line or graphical user interfaces.
-* '''Docker Daemon''': The Docker daemon, or `dockerd`, is the background service responsible for managing Docker containers and images. It listens for commands from the Docker client and handles the creation, execution, and monitoring of containers. It also manages Docker images and interfaces with the underlying operating system to handle resource allocation.
-* '''Docker Registry''': A Docker registry is a centralized repository for storing and distributing Docker images. Docker Hub is the default public registry, but users can also set up private registries for internal use. The registry allows developers to pull images for deployment or push their own images for others to use.
-=== Containerization ===
+=== Docker Registry ===
-Containerization is the core concept that differentiates Docker from traditional virtualization techniques. Unlike virtual machines that require a full operating system stack, Docker containers share the host operating system's kernel while isolating the application and its dependencies. This lightweight approach results in lower resource consumption and faster startup times.
-Containers can be created from Docker images, which are read-only snapshots of a filesystem that contains everything needed to run an application, including dependencies, libraries, and configuration files. Docker utilizes a layered filesystem, which allows images to share layers, optimizing storage and improving build times.
+Docker Registry is a storage and distribution system for Docker images. When a user builds an image, they can push it to a registry for storage and later retrieval. The most widely used public registry is Docker Hub, which hosts a vast collection of pre-built images available for use. Organizations can also set up private registries to store proprietary images securely. Docker registries enable version control and sharing of container images efficiently across teams and environments.
 == Implementation ==
-=== Installation and Setup ===
+The implementation of Docker is made simple through its command-line interface and various APIs, allowing for straightforward integration into existing workflows. The combination of Docker Engine, CLI tools, and various orchestration frameworks allows developers to create, manage, and scale containerized applications easily.
-Setting up Docker involves installing the Docker Engine on the host operating system. Docker supports various platforms, including Linux, Windows, and macOS. Installation typically requires downloading the appropriate package for the operating system or using package managers such as APT or Yum for Linux distributions.
-Once installed, the Docker service must be started, and the user can access the Docker client to begin creating and managing containers. Users may also configure Docker to run in rootless mode for additional security, enabling non-root users to create and manage containers without requiring administrative privileges.
+=== Installing Docker ===
-=== Basic Docker Commands ===
+Docker can be installed on various operating systems, including Linux, macOS, and Windows. The installation process may differ slightly depending on the host OS. Typically, users download the Docker Desktop application or install the Docker Engine using package management systems available for their operating systems. Following installation, users can verify the setup by running the `docker --version` command to confirm that Docker is functioning as expected.
-Docker commands are executed in a terminal and typically follow a standardized syntax, beginning with the `docker` command, followed by the action, and the object. Common commands include:
-* `docker run`: This command is used to create and start containers from specified Docker images. Users can specify options such as port mapping, environment variables, and volume mounts.
-* `docker ps`: This command retrieves a list of currently running containers, allowing users to view their status and resource usage.
-* `docker images`: This command displays a list of Docker images available locally, providing information about image sizes and tags.
-* `docker exec`: This command allows users to execute commands within a running container, facilitating interactive debugging or running scripts.
-* `docker-compose`: This tool, a part of Docker, allows users to define and run multi-container applications using a single YAML file. It simplifies the management of complex applications composed of multiple services.
-=== Dockerfile ===
+=== Creating Container Images ===
-A Dockerfile is a text document that contains a series of commands and instructions for building a Docker image. It defines the base image, commands for installing dependencies, setting environment variables, and specifying the command to run when the container starts.
-Dockerfiles allow automated image builds, ensuring that images are consistent and reproducible. Users can create a Dockerfile for their application, specifying every step needed to prepare the environment. Upon building the image, users often utilize the `docker build` command, which processes the Dockerfile and generates an image ready for deployment.
+Creating container images involves writing a `Dockerfile`, which contains a set of instructions for building an image. Instructions typically specify a base image, required files, environment variables, and command execution. Once the `Dockerfile` is defined, users can build images using the `docker build` command, specifying the Docker context from which the image will be built. The resulting images can then be run as containers.
-== Applications ==
+=== Running Containers ===
+Running containers is achieved with the `docker run` command, which allows users to execute a container from a specified image. The command supports various options to manage the container's behavior, such as mapping ports, mounting volumes, and assigning environment variables. Once a container is launched, it can be accessed through specified ports or integrated with other services.
+=== Orchestration and Scaling ===
+While Docker makes it easy to create and run containers, managing a large number of containers across different hosts can be challenging. To address this, Docker Swarm and Kubernetes emerged as popular orchestration tools.
+Docker Swarm is integrated directly into the Docker Engine, allowing users to set up a cluster of Docker nodes and deploy scaled applications across them. Swarm mode introduces concepts such as services, replicas, and load balancing, making distributed applications easier to manage.
-=== Broader Use Cases ===
+Kubernetes, on the other hand, is an open-source container orchestration platform that provides a more extensive set of features. Although initially developed by Google, it has become a widely adopted standard for orchestrating containerized applications. Kubernetes supports scaling, self-healing, service discovery, and rolling updates, making it a popular choice for managing container workloads in production environments.
-Docker is widely used across various domains of software development and deployment. It is particularly beneficial for microservices architecture, where applications are divided into smaller, independently deployable services. Each service can be encapsulated in its own container, while Docker orchestrators, such as Kubernetes, manage and scale these containerized applications.
-In addition to microservices, Docker is employed in continuous integration and continuous delivery (CI/CD) pipelines. It facilitates the automation of building, testing, and deploying applications by providing consistent environments across different stages of development. As a result, developers can identify and resolve issues more efficiently, reducing integration problems that often arise due to discrepancies between development and production environments.
+== Applications ==
-=== Cloud-Native Development ===
+Docker has found widespread applications across various sectors and in numerous development strategies. Organizations leverage Docker to simplify and accelerate their software development processes. Some of the most common applications include:
-With the rise of cloud-native applications, Docker has emerged as a key component of this paradigm. Cloud-native development focuses on building applications that can take advantage of cloud computing environments, emphasizing scalability, resilience, and flexibility. Docker enables developers to create applications designed for cloud infrastructure, utilizing container orchestration tools to manage resources dynamically.
-Furthermore, Docker containers are inherently portable, allowing developers to run their applications in any cloud service or on-premises infrastructure that supports Docker. This flexibility is particularly valuable in hybrid cloud environments, where organizations can distribute workloads across multiple cloud providers while maintaining a consistent operational model.
+=== Microservices Architecture ===
-=== DevOps Practices ===
+In a microservices architecture, applications are broken down into smaller, independent services that can be developed, deployed, and scaled independently. Docker is particularly well-suited to this approach, as it allows developers to encapsulate each microservice in its own container, ensuring that dependencies and configurations are isolated. This practice enhances the agility of development teams, enabling faster iterations and more manageable deployments.
-The adoption of Docker has been instrumental in promoting DevOps practices within organizations. By emphasizing collaboration between development and operations teams, Docker fosters an environment of shared responsibility for the entire application lifecycle. Its inherent features of isolation and reproducibility lead to faster development cycles and quicker feedback loops, contributing to improved software quality and quicker time-to-market.
-Using Docker in combination with configuration management tools, orchestration systems, and monitoring solutions facilitates DevOps automation. This holistic approach empowers teams to deploy, scale, and manage applications more effectively, leading to increased operational efficiency and enhanced customer satisfaction.
+=== Continuous Integration/Continuous Deployment (CI/CD) ===
-== Real-world Examples ==
+Docker plays a crucial role in CI/CD pipelines by providing a consistent environment for build, testing, and deployment phases. CI/CD tools such as Jenkins, GitLab CI/CD, and CircleCI integrate seamlessly with Docker, allowing automated testing of containerized applications. This consistency ensures that applications behave the same in development, testing, and production environments, thus reducing "it works on my machine" issues. By utilizing Docker, developers can streamline the release process and quickly deliver new features and fixes to users.
-=== Adoption in Enterprises ===
+=== Development and Testing Environments ===
-Docker has seen widespread adoption in enterprises of all sizes. Technology giants such as Google, Microsoft, and IBM have integrated Docker into their development processes and platforms. For instance, Google Cloud Platform offers native support for Docker, providing developers with a framework to deploy containerized applications seamlessly.
-Additionally, enterprises in industries such as finance, healthcare, and retail are leveraging Docker's capabilities to enhance their application deployment strategies. By containerizing legacy applications, organizations can improve resource utilization and mitigate compatibility issues during migrations to cloud environments.
+Docker significantly eases the process of setting up development and testing environments. Developers can create containers that mirror the production environment closely, leading to more reliable testing outcomes. They can quickly spin up or tear down instances of services and applications, allowing for experimentation without risking changes to the underlying infrastructure.
-=== Case Study: Spotify ===
+=== Hybrid and Multi-cloud Deployments ===
-Spotify, the music streaming service, has adopted Docker for its application development and deployment processes. The company employs containerization to improve the acquisition of development environments and manage its microservices architecture effectively. By using Docker, Spotify has been able to create consistent and reproducible environments for its services, enabling developers to focus more on coding and less on environment setup.
-The use of Docker has facilitated the rapid scaling of Spotify's systems to meet fluctuating demand, ensuring a smooth user experience during peak times. Furthermore, Docker's integration within their CI/CD pipeline has expedited the testing and deployment of new features and updates, leading to an agile and responsive software development process.
+Docker's portability allows organizations to deploy applications across various cloud providers or hybrid environments seamlessly. As a result, organizations can avoid vendor lock-in, utilizing the best features offered by different platforms. For instance, a company could deploy its application on both AWS and Google Cloud based on specific requirements, benefiting from the elasticity and scalability of both platforms.
 == Criticism and Limitations ==
+Despite its myriad advantages, Docker has faced some criticism and limitations that have been debated within the tech community.
 === Security Concerns ===
-Despite its many benefits, Docker is not without criticisms and limitations. One significant concern is the security implications of containerization. Containers share the host operating system's kernel, which can potentially expose vulnerabilities if an attacker gains access to one container. Inadequate security configurations may lead to privilege escalation, where an attacker could exploit a container to gain deeper access to the host system.
-To mitigate these risks, users are encouraged to adopt best practices for securing Docker containers. This includes using minimal base images, applying resource constraints, and leveraging capabilities such as Docker Security Profiles and user namespaces to control privileges.
+One major criticism of Docker stems from security. Given that containers share the host OS kernel, a vulnerability in one container can potentially impact others. Therefore, application isolation is less stringent compared to traditional virtual machines. Although improvements have been made in container security, such as the introduction of user namespaces and security profiles, organizations must implement strict policies and practices, routinely scanning images for vulnerabilities and ensuring that containers run with the least privilege principle.
-=== Complexity of Orchestration ===
+=== Complexity and Learning Curve ===
-While Docker allows for the management of individual containers, deploying and managing a production-scale environment often requires orchestration. Orchestrating a large number of containers can introduce complexities in terms of networking, load balancing, and service discovery. Popular orchestration tools, such as Kubernetes and Swarm, address these challenges but also involve their own learning curves and operational overhead.
-Furthermore, the choice of orchestration tooling can create vendor lock-in concerns, as relying heavily on a specific platform may limit flexibility in transitioning to other solutions.
+Novice users may encounter a steep learning curve when adopting Docker, especially when integrating it with other tools and workflows. Understanding how Docker containers work, how to write effective `Dockerfile` scripts, and navigating orchestration tools can be demanding. Furthermore, teams accustomed to monolithic application architectures may find it challenging to adapt to the microservices paradigm and the associated complexities.
-=== Performance Overhead ===
+=== Resource Overhead ===
-Although Docker containers are generally lightweight, some performance overhead may still be present compared to running applications directly on the host system. The additional layer of abstraction introduced by containerization can result in latency or reduced performance for high-throughput applications. For most use cases, this overhead is negligible, but applications that require maximum performance may still be better served by directly utilizing the host environment.
+While containers are generally more lightweight than traditional virtual machines, they still consume resources on the host machine. Running many containers on a single host can lead to resource contention, especially if not adequately managed. Organizations must monitor resource usage and apply limits on CPU and memory consumption for individual containers to maintain optimal performance.
+== Real-world Examples ==
+Many organizations, from startups to Fortune 500 companies, leverage Docker to enhance their development and deployment processes. A few notable examples include:
+=== Google ===
+Google adopted containerization early on and developed Kubernetes, which has become the industry standard for orchestrating Docker containers. Google itself utilizes Docker to manage its internal applications and services, benefiting from the scalability and portability that containerization offers.
+=== Netflix ===
+Netflix uses Docker to manage its microservices architecture, enabling the company to deploy thousands of microservices at scale. The ability to consistently and reliably deploy applications in transient environments has been pivotal in maintaining Netflix's seamless streaming service.
+=== IBM ===
+IBM has integrated Docker into its services and offerings, promoting hybrid cloud environments that utilize containerization. Docker provides IBM clients with flexibility and consistency for their applications, especially when transitioning between on-premise and cloud environments.
 == See also ==
 * [[Containerization]]
+* [[Kubernetes]]
 * [[Microservices]]
 * [[Virtualization]]
-* [[Kubernetes]]
 * [[DevOps]]
+* [[CI/CD]]
 == References ==
 * [https://www.docker.com Docker Official Website]
 * [https://docs.docker.com Docker Documentation]
-* [https://hub.docker.com Docker Hub]
+* [https://kubernetes.io Kubernetes Official Site]
+* [https://www.oracle.com/cloud/what-is-containerization.html Oracle Containerization Overview]
+* [https://www.opencontainers.org Open Container Initiative]
 [[Category:Software]]
 [[Category:Virtualization]]
-[[Category:Containerization]]
+[[Category:Containers]]