Improved Docker Roadmap. 🌨️ (#7029)

* Introduction.

* Namespaces.

* Installation & Setup

* Data Persistence.

* Databases.

* Building Container Images.

* Container Registries.

* Running Containers.

* Container Security

* Docker CLI. (Goated)

* Developer Experience.

* Deploying Containers + Extras.

* Few Refractors.

* Trim Content As Requested.

* Undo / Remove Refractors.

* Update 100-dockerhub.md

* Update 101-dockerhub-alt.md

* Update index.md

* Apply Requested Changes.

src/data/roadmaps/docker/content/100-introduction/100-what-are-containers.md

@@ -2,18 +2,12 @@
 
 Containers are lightweight, portable, and isolated software environments that allow developers to run and package applications with their dependencies, consistently across different platforms. They help to streamline application development, deployment, and management processes while ensuring that applications run consistently, regardless of the underlying infrastructure.
 
-## How do containers work?
-
-Unlike traditional virtualization, which emulates a complete operating system with its hardware resources, containers share the host's OS kernel and leverage lightweight virtualization techniques to create isolated processes. This approach leads to several benefits, including:
-
-- **Efficiency**: Containers have less overhead and can share common libraries and executable files, making it possible to run more containers on a single host compared to virtual machines (VMs).
-- **Portability**: Containers encapsulate applications and their dependencies, so they can easily be moved and run across different environments and platforms consistently.
-- **Fast startup**: Since containers don't need to boot a full OS, they can start up and shut down much faster than VMs.
-- **Consistency**: Containers provide a consistent environment for development, testing, and production stages of an application, reducing the "it works on my machine" problem.
-
 ## Containers and Docker
 
 Docker is a platform that simplifies the process of creating, deploying, and managing containers. It provides developers and administrators with a set of tools and APIs to manage containerized applications. With Docker, you can build and package application code, libraries, and dependencies into a container image, which can be distributed and run consistently in any environment that supports Docker.
 
-- [@official@What is a container?](https://www.docker.com/resources/what-container/)
+Visit the following resources to learn more:
+
+- [@official@What is a Container?](https://www.docker.com/resources/what-container/)
+- [@article@Introduction to Containers - AWS Skill Builder](https://explore.skillbuilder.aws/learn/course/106/introduction-to-containers)
 - [@feed@Explore top posts about Containers](https://app.daily.dev/tags/containers?ref=roadmapsh)

src/data/roadmaps/docker/content/100-introduction/101-need-for-containers.md

@@ -8,15 +8,6 @@ In the world of software development and deployment, consistency and efficiency
 
 - **Slow processes and scalability issues:** Traditional deployment methods have a slower time to market and scaling difficulties, which hinders fast delivery of software updates.
 
-How Containers Address These Challenges is as follows:
+Visit the following resources to learn more:
 
-- **Consistent environment:** Containers solve environment inconsistencies by bundling an application and its dependencies, configurations, and libraries into a single container. This guarantees that the application runs smoothly across different environments.
+- [@article@Need for Containers](https://www.redhat.com/en/topics/containers)
-
-- **Efficient resource utilization:** Unlike VMs, containers share underlying system resources and OS kernel, which makes them lightweight and efficient. Containers are designed to use fewer resources and boot up faster, improving resource utilization.
-
-- **Faster processes and scalability:** Containers can be easily created, destroyed, and replaced, leading to faster development and deployment cycles. Scaling applications becomes easier as multiple containers can be deployed without consuming significant resources.
-
-Overall, containers have become an essential tool for organizations that want to respond quickly to market changes, improve resource efficiency, and ensure reliable and consistent software delivery. They have revolutionized modern software development practices and have long-lasting impact in the world of deployment and application management.
-
-- [@article@Introduction to containers - AWS Skill Builder](https://explore.skillbuilder.aws/learn/course/106/introduction-to-containers)
-- [@feed@Explore top posts about Containers](https://app.daily.dev/tags/containers?ref=roadmapsh)

src/data/roadmaps/docker/content/100-introduction/102-bare-metal-vm-containers.md

@@ -1,7 +1,5 @@
 # Bare Metal vs VM vs Containers
 
-Here is a quick overview of the differences between bare metal, virtual machines, and containers.
-
 ## Bare Metal
 
 Bare metal is a term used to describe a computer that is running directly on the hardware without any virtualization. This is the most performant way to run an application, but it is also the least flexible. You can only run one application per server, and you cannot easily move the application to another server.
@@ -12,9 +10,8 @@ Virtual machines (VMs) are a way to run multiple applications on a single server
 
 ## Containers
 
-Containers are a way to run multiple applications on a single server without the overhead of a hypervisor. Each container runs on top of a container engine, which is a piece of software that emulates the operating system of a computer. The container engine allows you to run multiple applications on a single server, and it also provides isolation between applications running on different containers.
+Containers are a way to run multiple applications on a single server without the overhead of a hypervisor. Each container runs on top of a container engine, which is a piece of software that emulates the operating system of a computer.
 
 You can learn more from the following resources:
 
 - [@article@History of Virtualization](https://courses.devopsdirective.com/docker-beginner-to-pro/lessons/01-history-and-motivation/03-history-of-virtualization)
-- [@feed@Explore top posts about Containers](https://app.daily.dev/tags/containers?ref=roadmapsh)

src/data/roadmaps/docker/content/100-introduction/103-docker-and-oci.md

@@ -1,12 +1,8 @@
 # Docker and OCI
 
-The [Open Container Initiative (OCI)](https://opencontainers.org/) is a Linux Foundation project which aims at creating industry standards for container formats and runtimes. Its primary goal is to ensure the compatibility and interoperability of container environments through defined technical specifications.
+The Open Container Initiative (OCI) is a Linux Foundation project which aims at creating industry standards for container formats and runtimes. Its primary goal is to ensure the compatibility and interoperability of container environments through defined technical specifications.
 
-### Docker's role in OCI
+## OCI Specifications
-
-[Docker](https://www.docker.com/) is one of the founding members of the OCI, and it has played a pivotal role in shaping the standards for container formats and runtimes. Docker initially developed the container runtime (Docker Engine) and image format (Docker Image) that serve as the basis for OCI specifications.
-
-### OCI Specifications
 
 OCI has three main specifications:
 
@@ -16,9 +12,7 @@ OCI has three main specifications:
 
 - **Distribution Specification (distribution-spec):** It defines an API protocol to facilitate and standardize the distribution of content. Docker's existing registry API served as a starting point and heavily influenced the design of the OCI Distro Spec.
 
+You can learn more from the following resources:
 
-### Compatibility between Docker and OCI
+- [@official@Open Container Initiative](https://opencontainers.org/)
-
+- [@article@OCI - Wikipedia](https://en.wikipedia.org/wiki/Open_Container_Initiative)
-Docker remains committed to supporting the OCI specifications and, since its involvement in OCI, has continuously updated its software to be compliant with OCI standards. Docker's containerd runtime and image format are fully compatible with OCI specifications, enabling Docker containers to be run by other OCI-compliant container runtimes and vice versa.
-
-In summary, Docker and the Open Container Initiative work together to maintain standardization and compatibility within the container industry. Docker has played a significant role in the development of the OCI specifications, ensuring that the container ecosystem remains healthy, interoperable, and accessible to a wide range of users and platforms across the industry.

src/data/roadmaps/docker/content/100-introduction/index.md

@@ -1,3 +1,8 @@
 # What is Docker?
 
 Docker is an open-source platform that automates the deployment, scaling, and management of applications by isolating them into lightweight, portable containers. Containers are standalone executable units that encapsulate all necessary dependencies, libraries, and configuration files required for an application to run consistently across various environments.
+
+Visit the following resources to learn more:
+
+- [@official@Docker](https://www.docker.com/)
+- [@official@Docker Docs](https://www.docs.docker.com/)

src/data/roadmaps/docker/content/101-underlying-technologies/100-namespaces.md

@@ -1,8 +1,4 @@
-# Namespaces
+# What are Namespaces?
-
-Namespaces are one of the core technologies that Docker uses to provide isolation between containers. In this section, we'll briefly discuss what namespaces are and how they work.
-
-### What are Namespaces?
 
 In the Linux kernel, namespaces are a feature that allows the isolation of various system resources, making it possible for a process and its children to have a view of a subset of the system that is separate from other processes. Namespaces help to create an abstraction layer to keep containerized processes separate from one another and from the host system.
 
@@ -15,10 +11,6 @@ There are several types of namespaces in Linux, including:
 - **User (USER)**: Maps user and group identifiers between the container and the host, so different permissions can be set for resources within the container.
 - **IPC (Inter-Process Communication)**: Allows or restricts the communication between processes in different containers.
 
-### How Docker uses Namespaces
+Visit the following resources to learn more:
-
-Docker uses namespaces to create isolated environments for containers. When a container is started, Docker creates a new set of namespaces for that container. These namespaces only apply within the container, so any processes running inside the container have access to a subset of system resources that are isolated from other containers as well as the host system.
-
-By leveraging namespaces, Docker ensures that containers are truly portable and can run on any system without conflicts or interference from other processes or containers running on the same host.
 
-In summary, namespaces provide a level of resource isolation that enables running multiple containers with separate system resources within the same host, without them interfering with each other. This is a critical feature that forms the backbone of Docker's container technology.
+- [@official@Docker Namespaces](https://docs.docker.com/engine/security/userns-remap/)

src/data/roadmaps/docker/content/101-underlying-technologies/101-cgroups.md

@@ -4,20 +4,7 @@
 
 Docker utilizes cgroups to enforce resource constraints on containers, allowing them to have a consistent and predictable behavior. Below are some of the key features and benefits of cgroups in the context of Docker containers:
 
-### Resource Isolation
+Visit the following resources to learn more:
 
-cgroups helps to confine each container to a specific set of resources, ensuring fair sharing of system resources among multiple containers. This enables better isolation between different containers, so that a misbehaving container does not consume all available resources, thereby negatively affecting other containers.
+- [@official@Control Groups](https://www.docker.com/resources/what-container/#control-groups)
-
+- [@article@Control Groups - Medium](https://medium.com/@furkan.turkal/how-does-docker-actually-work-the-hard-way-a-technical-deep-diving-c5b8ea2f0422)
-### Limiting Resources
-
-With cgroups, you can set limits on various system resources used by a container, such as CPU, memory, and I/O. This helps to prevent a single container from consuming excessive resources and causing performance issues for other containers or the host system.
-
-### Prioritizing Containers
-
-By allocating different shares of resources, cgroups allows you to give preference or priority to certain containers. This can be useful in scenarios where some containers are more critical than others, or during high resource contention situations.
-
-### Monitoring
-
-cgroups also offers mechanisms for monitoring the resource usage of individual containers, which helps to gain insights into container performance and identify potential resource bottlenecks.
-
-Overall, cgroups is an essential underlying technology in Docker. By leveraging cgroups, Docker provides a robust and efficient container runtime environment, ensuring the containers have the required resources while maintaining good overall system performance.

src/data/roadmaps/docker/content/101-underlying-technologies/index.md

@@ -4,16 +4,21 @@ Understanding the core technologies that power Docker will provide you with a de
 
 ## Linux Containers (LXC)
 
-Linux Containers (LXC) enables running multiple independent Linux systems on a single computer. Acting as isolated spaces, LXC containers share host resources like memory and processing power, without needing their own full operating system copy, ensuring lightweight and fast startup. Portable across compatible Linux systems, they find utility in diverse tasks such as running separate applications, testing software, or deploying cloud services. With user-friendly management tools available, LXC simplifies container creation, monitoring, and management.
+Linux Containers (LXC) enables running multiple independent Linux systems on a single computer. Acting as isolated spaces, LXC containers share host resources like memory and processing power, without needing their own full operating system copy, ensuring lightweight and fast startup.
 
 ## Control Groups (cgroups)
 
-Control Groups (cgroups) is a Linux kernel feature that allows the allocation and management of resources like CPU, memory, and I/O to a set of processes. Docker leverages cgroups to limit the resources used by containers and ensure that one container does not monopolize the resources of the host system.
+Control Groups (cgroups) is a Linux kernel feature that allows the allocation and management of resources like CPU, memory, and I/O to a set of processes.
 
 ## Union File Systems (UnionFS)
 
-UnionFS is a file system service that allows the overlaying of multiple file systems in a single, unified view. Docker uses UnionFS to create a layered approach for images and containers, which enables better sharing of common files and faster container creation.
+UnionFS is a file system service that allows the overlaying of multiple file systems in a single, unified view.
 
 ## Namespaces
 
-Namespaces are another Linux kernel feature that provides process isolation. They allow Docker to create isolated workspaces called containers. Namespaces ensure that processes within a container cannot interfere with processes outside the container or on the host system. There are several types of namespaces, like PID, NET, MNT, and USER, each responsible for isolating a different aspect of a process.
+Namespaces are another Linux kernel feature that provides process isolation.
+
+Visit the following resources to learn more:
+
+- [@official@Underlying Technologies](https://www.docker.com/resources/what-container/#underlying-technologies)
+- [@article@Underlying Technologies - Medium](https://medium.com/@furkan.turkal/how-does-docker-actually-work-the-hard-way-a-technical-deep-diving-c5b8ea2f0422)

src/data/roadmaps/docker/content/102-installation-setup/100-docker-desktop.md

@@ -2,33 +2,17 @@
 
 Docker Desktop is an easy-to-install application that enables developers to quickly set up a Docker environment on their desktop machines. It is available for both Windows and macOS operating systems. Docker Desktop is designed to simplify the process of managing and running Docker containers, providing a user-friendly interface and seamless integration with the host operating system.
 
-### Features
+## Installation
-
-- **Ease of installation**: Docker Desktop provides a straightforward installation process, allowing users to quickly set up Docker on their machines.
-- **Automatic updates**: The application will automatically update to the latest version of Docker, ensuring that your environment stays up-to-date and secure.
-- **Docker Hub integration**: The Docker Desktop interface allows for easy access to Docker Hub, enabling users to find, share and manage Docker images.
-- **Containers and Services management**: Docker Desktop simplifies container and service management with a user-friendly GUI that allows users to monitor, start, stop and delete containers and services.
-- **Kubernetes integration**: Docker Desktop comes with built-in Kubernetes support, which can be enabled with just a click. This makes it easier to develop, test and run Kubernetes applications locally.
-- **Resource allocation**: Docker Desktop allows users to configure the amount of resources (CPU, memory, and storage) allocated to containers and services.
-
-### Installation
 
 To install Docker Desktop on your machine, follow these steps:
 
-- **Download the installer**: You can download the installer for your operating system from the [Docker Desktop website](https://www.docker.com/products/docker-desktop). Make sure to choose the appropriate version (Windows or Mac).
+- **Download the installer**: You can download the installer for your operating system from the Docker Desktop website. Make sure to choose the appropriate version (Windows or Mac).
 - **Run the installer**: Double-click on the downloaded installer file and follow the setup wizard to complete the installation process.
-- **Launch Docker Desktop**: Once the installation is complete, start Docker Desktop and sign in with your Docker Hub account. If you don't have an account, you can sign up for a free account on the [Docker Hub website](https://hub.docker.com/).
+- **Launch Docker Desktop**: Once the installation is complete, start Docker Desktop and sign in with your Docker Hub account. If you don't have an account, you can sign up for a free account on the Docker Hub website.
-- **Verify installation**: Open a terminal or command prompt and run the following command to verify that Docker Desktop has been installed correctly:
-
-  ```bash
-  docker --version
-  ```
-
-  If the installation was successful, the command should output the Docker version information.
 
 Learn more from the following resources:
 
-- [@article@Docker Desktop Documentation](https://docs.docker.com/desktop/)
+- [@official@Docker Desktop Documentation](https://docs.docker.com/desktop/)
-- [@article@Docker Get Started Guide](https://docs.docker.com/get-started/)
+- [@official@Docker Get Started Guide](https://docs.docker.com/get-started/)
-- [@article@Docker Hub](https://hub.docker.com/)
+- [@official@Docker Hub](https://hub.docker.com/)
 - [@feed@Explore top posts about Docker](https://app.daily.dev/tags/docker?ref=roadmapsh)

src/data/roadmaps/docker/content/102-installation-setup/101-docker-engine.md

@@ -1,15 +1,13 @@
 # Docker Engine
 
-There is often confusion between "Docker Desktop" and "Docker Engine". Docker Engine refers specifically to a subset of the Docker Desktop components which are free and open source and can be installed only on Linux.
+There is often confusion between "Docker Desktop" and "Docker Engine". Docker Engine refers specifically to a subset of the Docker Desktop components which are free and open source and can be installed only on Linux. Docker Engine can build container images, run containers from them, and generally do most things that Docker Desktop can, but it is Linux only and doesn't provide all of the developer experience polish that Docker Desktop provides.
 
 Docker Engine includes:
 
 - Docker Command Line Interface (CLI)
 - Docker daemon (dockerd), exposing the Docker Application Programming Interface (API)
 
-Docker Engine can build container images, run containers from them, and generally do most things that Docker Desktop can, but it is Linux only and doesn't provide all of the developer experience polish that Docker Desktop provides.
-
 For more information about docker engine see:
 
-- [@article@Docker Engine - Docker Documentation](https://docs.docker.com/engine/)
+- [@official@Docker Engine - Docker Documentation](https://docs.docker.com/engine/)
 - [@feed@Explore top posts about Docker](https://app.daily.dev/tags/docker?ref=roadmapsh)

src/data/roadmaps/docker/content/102-installation-setup/index.md

@@ -3,4 +3,4 @@
 Docker provides a desktop application called **Docker Desktop** that simplifies the installation and setup process. There is also another option to install using the **Docker Engine**.
 
 - [@official@Docker Desktop website](https://www.docker.com/products/docker-desktop)
-- [@article@Docker Engine](https://docs.docker.com/engine/install/)
+- [@official@Docker Engine](https://docs.docker.com/engine/install/)

src/data/roadmaps/docker/content/104-data-persistence/100-ephemeral-container-fs.md

@@ -1,10 +1,10 @@
-### Ephemeral FS
+# Ephemeral FS
 
 By default, the storage within a Docker container is ephemeral, meaning that any data changes or modifications made inside a container will only persist as long as the container is running. Once the container is stopped and removed, all the associated data will be lost. This is because Docker containers are designed to be stateless by nature.
 
 This temporary or short-lived storage is called the "ephemeral container file system". It is an essential feature of Docker, as it enables fast and consistent deployment of applications across different environments without worrying about the state of a container.
 
-### Ephemeral FS and Data Persistence
+## Ephemeral FS and Data Persistence
 
 As any data stored within the container's ephemeral FS is lost when the container is stopped and removed, it poses a challenge to data persistence in applications. This is especially problematic for applications like databases, which require data to be persisted across multiple container life cycles.
 
@@ -14,4 +14,6 @@ To overcome these challenges, Docker provides several methods for data persisten
 - **Bind mounts**: Mapping a host machine's directory or file into a container, effectively sharing host's storage with the container.
 - **tmpfs mounts**: In-memory storage, useful for cases where just the persistence of data within the life-cycle of the container is required.
 
-By implementing these strategies, Docker ensures that application data can be preserved beyond the life-cycle of a single container, making it possible to work with stateful applications.
+Visit the following resources to learn more:
+
+- [@official@Data Persistence - Docker Documentation](https://docs.docker.com/get-started/docker-concepts/running-containers/persisting-container-data/)

src/data/roadmaps/docker/content/104-data-persistence/101-volume-mounts.md

@@ -34,9 +34,6 @@ docker run -d --mount source=my-volume,destination=/data your-image
 
 In both examples above, `my-volume` is the name of the volume we created earlier, and `/data` is the path inside the container where the volume will be mounted.
 
-> For an in-depth exploration of the `-v` and `--mount` flags, consult Docker's official guide on [Choose the -v or --mount flag](https://docs.docker.com/storage/bind-mounts/#choose-the--v-or---mount-flag).
-
-
 ## Sharing Volumes Between Containers
 
 To share a volume between multiple containers, simply mount the same volume on multiple containers. Here's how to share `my-volume` between two containers running different images:
@@ -56,6 +53,7 @@ To remove a volume, you can use the `docker volume rm` command followed by the v
 docker volume rm my-volume
 ```
 
-That's it! Now you have a basic understanding of volume mounts in Docker. You can use them to persist and share data between your containers efficiently and securely.
+Visit the following resources to learn more:
 
-- [@article@Docker Volumes](https://docs.docker.com/storage/volumes/).
+- [@official@Docker Volumes](https://docs.docker.com/storage/volumes/).
+- [@official@Docker Volume Flags](https://docs.docker.com/storage/bind-mounts/#choose-the--v-or---mount-flag)

src/data/roadmaps/docker/content/104-data-persistence/102-bind-mounts.md

@@ -2,8 +2,6 @@
 
 Bind mounts have limited functionality compared to volumes. When you use a bind mount, a file or directory on the host machine is mounted into a container. The file or directory is referenced by its absolute path on the host machine. By contrast, when you use a volume, a new directory is created within Docker’s storage directory on the host machine, and Docker manages that directory’s contents.
 
-The file or directory does not need to exist on the Docker host already. It is created on demand if it does not yet exist. Bind mounts are very performant, but they rely on the host machine’s filesystem having a specific directory structure available.
+Visit the following resources to learn more:
 
-Learn more about bind mounts here:
+- [@official@Docker Bind Mounts](https://docs.docker.com/storage/bind-mounts/)
-
-- [@article@Docker Bind Mounts](https://docs.docker.com/storage/bind-mounts/)

src/data/roadmaps/docker/content/104-data-persistence/index.md

@@ -1,3 +1,7 @@
 # Data Persistence in Docker
 
-Docker enables you to run containers that are isolated pieces of code, including applications and their dependencies, separated from the host operating system. Containers are ephemeral by default, which means any data stored in the container will be lost once it is terminated. To overcome this problem and retain data across container lifecycles, Docker provides various data persistence methods.
+Docker enables you to run containers that are isolated pieces of code, including applications and their dependencies, separated from the host operating system. Containers are ephemeral by default, which means any data stored in the container will be lost once it is terminated. To overcome this problem and retain data across container lifecycle, Docker provides various data persistence methods.
+
+Visit the following resources to learn more:
+
+- [@official@Data Persistence - Docker Documentation](https://docs.docker.com/get-started/docker-concepts/running-containers/persisting-container-data/)

src/data/roadmaps/docker/content/105-using-third-party-images/100-databases.md

@@ -1,29 +1,7 @@
-# Using Third Party Images: Databases
+# Using Databases
 
 Running your database in a Docker container can help streamline your development process and ease deployment. Docker Hub provides numerous pre-made images for popular databases such as MySQL, PostgreSQL, and MongoDB.
 
-### Example: Using MySQL Image
-
-To use a MySQL database, search for the official image on Docker Hub:
-
-```bash
-docker search mysql
-```
-
-Find the official image, and pull it:
-
-```bash
-docker pull mysql
-```
-
-Now, you can run a MySQL container. Specify the required environment variables, such as `MYSQL_ROOT_PASSWORD`, and optionally map the container's port to your host machine:
-
-```bash
-docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -p 3306:3306 -d mysql
-```
-
-This command creates a new container named `some-mysql`, sets the root password to `my-secret-pw`, and maps port 3306 on the host to port 3306 on the container.
-
 ## Example: Using PostgreSQL Image
 
 For PostgreSQL, follow similar steps to those outlined above. First, search for the official image:
@@ -44,22 +22,6 @@ Run a PostgreSQL container, specifying environment variables such as `POSTGRES_P
 docker run --name some-postgres -e POSTGRES_PASSWORD=my-secret-pw -p 5432:5432 -d postgres
 ```
 
-### Example: Using MongoDB Image
+Visit the following resources to learn more:
-
-Running a MongoDB container with Docker follows a similar pattern as previous examples. Search for the official image:
-
-```bash
-docker search mongo
-```
-
-Pull the image:
 
-```bash
+- [@official@Containerized Databases](https://docs.docker.com/guides/use-case/databases/)
-docker pull mongo
-```
-
-Run a MongoDB container:
-
-```bash
-docker run --name some-mongo -p 27017:27017 -d mongo
-```

src/data/roadmaps/docker/content/105-using-third-party-images/101-interactive-test-environments.md

@@ -4,7 +4,7 @@ Docker allows you to create isolated, disposable environments that can be delete
 
 ## Creating an Interactive Test Environment with Docker
 
-To demonstrate how to setup an interactive test environment, let's use the Python programming language as an example. We will use a public Python image available on [Docker Hub](https://hub.docker.com/_/python).
+To demonstrate how to setup an interactive test environment, let's use the Python programming language as an example. We will use a public Python image available on Docker Hub.
 
 - To start an interactive test environment using the Python image, simply run the following command:
 
@@ -22,28 +22,6 @@ print("Hello, Docker!")
 
 - Once you are done with your interactive session, you can simply type `exit()` or press `CTRL+D` to exit the container. The container will be automatically removed as specified by the `--rm` flag.
 
-## More Examples of Interactive Test Environments
+Visit the following resources to learn more:
 
-You can use several third-party images available on Docker Hub and create various interactive environments such as:
+- [@article@Test Environments - Medium](https://manishsaini74.medium.com/containerized-testing-orchestrating-test-environments-with-docker-5201bfadfdf2)
-
-- **Node.js**: To start an interactive Node.js shell, you can use the following command:
-
-```bash
-docker run -it --rm node
-```
-
-- **Ruby**: To start an interactive Ruby shell, you can use the following command:
-
-```bash
-docker run -it --rm ruby
-```
-
-- **MySQL**: To start a temporary MySQL instance, you can use the following command:
-
-```bash
-docker run -it --rm --name temp-mysql -e MYSQL_ALLOW_EMPTY_PASSWORD=yes -p 3306:3306 mysql
-```
-
-This will start a temporary MySQL server that can be accessed via host port 3306. It will be removed once the container is stopped.
-
-Feel free to explore and test various software without worrying about damaging your local machine or installing unnecessary dependencies. Using Docker for interactive test environments allows you to work more efficiently and cleanly when dealing with various third-party software.

src/data/roadmaps/docker/content/105-using-third-party-images/102-command-line-utilities.md

@@ -1,8 +1,8 @@
 # Command Line Utilities
 
-Docker images can include command line utilities or standalone applications that we can run inside containers. This can be really useful when working with third-party images, as the tools we want to use are already packaged and available to be run without any installation or configuration.
+Docker images can include command line utilities or standalone applications that we can run inside containers.
 
-### BusyBox
+## BusyBox
 
 BusyBox is a small (1-2 Mb) and simple command line application that provides a large number of the commonly used Unix utilities, such as `awk`, `grep`, `vi`, etc. To run BusyBox inside a Docker container, you simply need to pull the image and run it with Docker:
 
@@ -11,8 +11,6 @@ docker pull busybox
 docker run -it busybox /bin/sh
 ```
 
-Once inside the container, you can start running various BusyBox utilities just like you would on a regular command line.
-
 ### cURL
 
 cURL is a well-known command line tool that can be used to transfer data using various network protocols. It is often used for testing APIs or downloading files from the internet. To use cURL inside a Docker container, you can use the official cURL image available on Docker Hub:
@@ -22,16 +20,10 @@ docker pull curlimages/curl
 docker run --rm curlimages/curl https://example.com
 ```
 
-In this example, the `--rm` flag is used to remove the container after the command has finished running. This is useful when you only need to run a single command and then clean up the container afterwards.
+In this example, the `--rm` flag is used to remove the container after the command has finished running.
-
-### Other Command Line Utilities
-
-There are numerous command line utilities available in Docker images, including but not limited to:
-
-- `wget`: A free utility for non-interactive download of files from the Web.
-- `imagemagick`: A powerful software suite for image manipulation and conversion.
-- `jq`: A lightweight and flexible command-line JSON processor.
 
-To use any of these tools, you can search for them on Docker Hub and follow the instructions provided in their respective repositories. 
+Visit the following resources to learn more:
 
-In conclusion, using third-party Docker images for command line utilities can save time, simplify your development setup, and help ensure a consistent environment across different machines. You can experiment with different utilities and tools as you expand your knowledge and use of Docker.
+- [@official@Docker Images](https://docs.docker.com/engine/reference/commandline/images/)
+- [@official@Docker Run](https://docs.docker.com/reference/cli/docker/container/run/)
+- [@official@Docker Pull](https://docs.docker.com/engine/reference/commandline/pull/)

src/data/roadmaps/docker/content/105-using-third-party-images/index.md

@@ -1,27 +1,19 @@
 # Using Third Party Images
 
-Third-party images are pre-built Docker container images that are available on Docker Hub or other container registries. These images are created and maintained by individuals or organizations and can be used as a starting point for your containerized applications.
+Third-party images are pre-built Docker container images that are available on [Docker Hub](https://hub.docker.com) or other container registries. These images are created and maintained by individuals or organizations and can be used as a starting point for your containerized applications.
 
-## Finding Third-Party Images
+## Using an Image in Your Dockerfile
-
-[Docker Hub](https://hub.docker.com) is the largest and most popular container image registry containing both official and community-maintained images. You can search for images based on the name or the technology you want to use.
 
 For example: If you're looking for a `Node.js` image, you can search for "node" on Docker Hub and you'll find the official Node.js image along with many other community-maintained images.
 
-## Using an Image in Your Dockerfile
-
 To use a third-party image in your Dockerfile, simply set the image name as the base image using the `FROM` directive. Here's an example using the official Node.js image:
 
 ```dockerfile
-FROM node:14
+FROM node:20
 
 # The rest of your Dockerfile...
 ```
 
-## Be Aware of Security Concerns
+Visit the following resources to learn more:
-
-Keep in mind that third-party images can potentially have security vulnerabilities or misconfigurations. Always verify the source of the image and check its reputation before using it in production. Prefer using official images or well-maintained community images.
-
-## Maintaining Your Images
 
-When using third-party images, it's essential to keep them updated to incorporate the latest security updates and dependency changes. Regularly check for updates in your base images and rebuild your application containers accordingly.
+- [@official@Docker Hub Registry](https://hub.docker.com/)

src/data/roadmaps/docker/content/106-building-container-images/100-dockerfiles.md

@@ -1,6 +1,6 @@
 # Dockerfile
 
-A Dockerfile is a text document that contains a list of instructions used by the Docker engine to build an image. Each instruction in the Dockerfile adds a new layer to the image. Docker will build the image based on these instructions, and then you can run containers from the image. Dockerfiles are one of the main elements of *infrastructure as code*.
+A Dockerfile is a text document that contains a list of instructions used by the Docker engine to build an image. Each instruction in the Dockerfile adds a new layer to the image. Docker will build the image based on these instructions, and then you can run containers from the image.
 
 ## Structure of a Dockerfile
 
@@ -35,26 +35,8 @@ ENV NAME World
 CMD ["python", "app.py"]
 ```
 
-## Common Dockerfile Instructions
+Visit the following resources to learn more:
 
-Here's a list of some common Dockerfile instructions and their purpose:
+- [@official@Dockerfile Reference](https://docs.docker.com/engine/reference/builder/)
-
+- [@official@Dockerfile Best Practices](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/)
-- `FROM`: Sets the base image to begin with. It is mandatory to have `FROM` as the first instruction in the Dockerfile.
+- [@opensource@Dockerfile Examples](https://github.com/dockersamples)
-- `WORKDIR`: Sets the working directory for any `RUN`, `CMD`, `ENTRYPOINT`, `COPY` or `ADD` instructions. If the directory does not exist, it will be created automatically.
-- `COPY`: Copies files or directories from the host into the container's file system.
-- `ADD`: Similar to `COPY`, but can also handle remote URLs and automatically unpack archives.
-- `RUN`: Executes a command within the image as a new layer.
-- `CMD`: Defines the default command to execute when running a container from the image.
-- `ENTRYPOINT`: Similar to `CMD`, but it's designed to allow a container as an executable with its own parameters.
-- `EXPOSE`: Informs Docker that the container will listen on the specified network ports at runtime.
-- `ENV`: Sets environment variables for the container.
-
-## Building an Image from a Dockerfile
-
-To build an image from the Dockerfile, use the `docker build` command, specifying the build context (usually the current directory), and an optional tag for the image.
-
-```bash
-docker build -t my-image:tag .
-```
-
-After running this command, Docker will execute each instruction in the Dockerfile, in order, creating a new layer for each.

src/data/roadmaps/docker/content/106-building-container-images/101-efficient-layer-caching.md

@@ -14,6 +14,7 @@ FROM node:14
 WORKDIR /app
 
 COPY package.json /app/
+
 RUN npm install
 
 COPY . /app/
@@ -21,22 +22,6 @@ COPY . /app/
 CMD ["npm", "start"]
 ```
 
-When you build the image for the first time, Docker will execute each instruction and create a new layer for each of them. If you make some changes to the application and build the image again, Docker will check if the changed instructions affect any of the layers. If none of the layers is affected by the changes, Docker will reuse the cached layers.
-
-## Tips for Efficient Layer Caching
-
-- **Minimize changes in the Dockerfile:** Try to minimize the frequency of changes in your Dockerfile, and structure your instructions in a way that most frequently changed lines appear at the bottom.
-
-- **Build context optimization:** Use `.dockerignore` file to exclude unnecessary files from the build context that might cause cache invalidation. 
-
-- **Use smaller base images:** Smaller base images reduce the time taken to pull the base image as well as the number of layers that need to be cached. 
-
-- **Leverage the Docker's `--cache-from` flag:** If you're using a CI/CD pipeline, you can specify which image to use as a cache source.
-
-- **Combine multiple instructions:** In some cases, combining instructions (e.g., `RUN`) can help minimize the number of layers, making caching more efficient.
-
-By following these best practices, you can optimize the layer caching process and reduce the build time for your Docker images, making your development and deployment processes more efficient.
-
 Visit the following resources to learn more:
 
-- [@article@Docker Layer Caching](https://docs.docker.com/build/cache/)
+- [@official@Docker Layer Caching](https://docs.docker.com/build/cache/)

src/data/roadmaps/docker/content/106-building-container-images/102-image-size-and-security.md

@@ -1,8 +1,4 @@
-# Image Size and Security
+# Reducing Image Size
-
-When building container images, it's essential to be aware of both image size and security. The size of the image affects the speed at which your containers are built and deployed. Smaller images lead to faster builds and reduced network overhead when downloading the image. Security is crucial because container images can contain vulnerabilities that could potentially put your applications at risk.
-
-## Reducing Image Size
 
 - **Use an appropriate base image:** Choose a smaller, more lightweight base image that includes only the necessary components for your application. For example, consider using the `alpine` variant of an official image, if available, as it's typically much smaller in size.
 
@@ -28,53 +24,15 @@ When building container images, it's essential to be aware of both image size an
 
 - **Use multi-stage builds:** Use multi-stage builds to create smaller images. Multi-stage builds allow you to use multiple `FROM` statements in your Dockerfile. Each `FROM` statement creates a new stage in the build process. You can copy files from one stage to another using the `COPY --from` statement.
 
-  ```dockerfile
-  FROM node:14-alpine AS build
-  WORKDIR /app
-  COPY package*.json ./
-  RUN npm install
-  COPY . .
-  RUN npm run build
-
-  FROM node:14-alpine
-  WORKDIR /app
-  COPY --from=build /app/dist ./dist
-  COPY package*.json ./
-  RUN npm install --production
-  CMD ["npm", "start"]
-  ```
-
 - **Use `.dockerignore` file:** Use a `.dockerignore` file to exclude unnecessary files from the build context that might cause cache invalidation and increase the final image size.
 
-  ```
+  ```dockerfile
   node_modules
   npm-debug.log
   ```
 
-## Enhancing Security
-
-- **Keep base images updated:** Regularly update the base images you're using in your Dockerfiles to ensure they include the latest security patches.
-
-- **Avoid running containers as root:** Always use a non-root user when running your containers to minimize potential risks. Create a user and switch to it before running your application.
-
-  ```dockerfile
-  RUN addgroup -g 1000 appuser && \
-      adduser -u 1000 -G appuser -D appuser
-  USER appuser
-  ```
-
-- **Limit the scope of `COPY` or `ADD` instructions:** Be specific about the files or directories you're copying into the container image. Avoid using `COPY . .` as it may unintentionally include sensitive files.
-
-  ```dockerfile
-  COPY package*.json ./
-  COPY src/ src/
-  ```
-
-- **Scan images for vulnerabilities:** Use tools like [Anchore](https://anchore.com/) or [Clair](https://github.com/quay/clair) to scan your images for vulnerabilities and fix them before deployment.
-
-By following these best practices, you'll be able to build more efficient and secure container images, leading to improved performance and a reduced risk of vulnerabilities in your applications.
-
 Visit the following resources to learn more:
 
 - [@official@Multi-stage builds](https://docs.docker.com/build/building/multi-stage/)
+- [@official@Docker Best Practices](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/)
 - [@feed@Explore top posts about Security](https://app.daily.dev/tags/security?ref=roadmapsh)

src/data/roadmaps/docker/content/106-building-container-images/index.md

@@ -29,61 +29,8 @@ ENV NAME World
 CMD ["python", "app.py"]
 ```
 
-## Building an Image
+Visit the following resources to learn more:
 
-Once you have created the Dockerfile, you can build the image using the `docker build` command. Execute the following command in the terminal from the directory containing the Dockerfile:
+- [@official@Docker Image Builder](https://docs.docker.com/reference/cli/docker/buildx/build/)
-
+- [@official@Dockerfile Reference](https://docs.docker.com/engine/reference/builder/)
-```sh
+- [@opensource@Dockerfile Examples](https://github.com/dockersamples)
-docker build -t your-image-name .
-```
-
-This command tells Docker to build an image using the Dockerfile in the current directory (`.`), and assign it a name (`-t your-image-name`).
-
-## Inspecting Images and Layers
-
-After a successful build, you can inspect the created image using `docker image` command:
-
-```sh
-docker image ls
-```
-
-To take a closer look at the individual layers of an image, use the `docker history` command:
-
-```sh
-docker history your-image-name
-```
-
-To view the layers of an image, you can also use the `docker inspect` command:
-
-```sh
-docker inspect your-image-name
-```
-
-To remove an image, use the `docker image rm` command:
-
-```sh
-docker image rm your-image-name
-```
-
-
-## Pushing Images to a Registry
-
-Once your image is built, you can push it to a container registry (e.g., Docker Hub, Google Container Registry, etc.) to easily distribute and deploy your application. First, log in to the registry using your credentials:
-
-```sh
-docker login
-```
-
-Then, tag your image with the registry URL:
-
-```sh
-docker tag your-image-name username/repository:tag
-```
-
-Finally, push the tagged image to the registry:
-
-```sh
-docker push username/repository:tag
-```
-
-Building container images is a crucial aspect of using Docker, as it enables you to package and deploy your applications with ease. By creating a Dockerfile with precise instructions, you can effortlessly build and distribute images across various platforms.

src/data/roadmaps/docker/content/107-container-registries/100-dockerhub.md

@@ -1,25 +1,22 @@
 # DockerHub
 
-[DockerHub](https://hub.docker.com/) is a cloud-based registry service provided by Docker Inc. It is the default public container registry where you can store, manage, and distribute your Docker images. DockerHub makes it easy for other users to find and use your images or to share their own images with the Docker community.
+DockerHub is a cloud-based registry service provided by Docker Inc. It is the default public container registry where you can store, manage, and distribute your Docker images.
 
 ## Features of DockerHub
 
 - **Public and private repositories:** Store your images in public repositories that are accessible to everyone, or opt for private repositories with access limited to your team or organization.
 
-- **Automated Builds:** DockerHub integrates with popular code repositories such as GitHub and Bitbucket, allowing you to set up automated builds for your Docker images. Whenever you push code to the repository, DockerHub will automatically create a new image with the latest changes.
+- **Automated Builds:** DockerHub integrates with popular code repositories such as GitHub and Bitbucket, allowing you to set up automated builds for your Docker images
 
 - **Webhooks:** DockerHub allows you to configure webhooks to notify other applications or services when an image has been built or updated.
 
 - **Organizations and Teams:** Make collaboration easy by creating organizations and teams to manage access to your images and repositories.
 
-- **Official Images:** DockerHub provides a curated set of official images for popular software like MongoDB, Node.js, Redis, etc. These images are maintained by Docker Inc. and the upstream software vendor, ensuring that they are up-to-date and secure.
+- **Official Images:** DockerHub provides a curated set of official images for popular software like MongoDB, Node.js, Redis, etc. These images are maintained by Docker Inc.
 
-To start using DockerHub, you need to create a free account on their website. Once you've signed up, you can create repositories, manage organizations and teams, and browse the available images.
+To push an image to DockerHub, you need to log in to the registry using your DockerHub credentials:
-
-When you're ready to share your own images, you can use the `docker` command line tool to push your local images to DockerHub:
 
 ```bash
-docker login
 docker tag your-image your-username/your-repository:your-tag
 docker push your-username/your-repository:your-tag
 ```
@@ -30,4 +27,8 @@ To pull images from DockerHub, you can use the `docker pull` command:
 docker pull your-username/your-repository:your-tag
 ```
 
-DockerHub is essential for distributing and sharing Docker images, making it easier for developers to deploy applications and manage container infrastructure.
+Visit the following resources to learn more:
+
+- [@official@DockerHub](https://hub.docker.com/)
+- [@official@DockerHub Repositories](https://docs.docker.com/docker-hub/repos/)
+- [@official@DockerHub Webhooks](https://docs.docker.com/docker-hub/webhooks/)

src/data/roadmaps/docker/content/107-container-registries/101-dockerhub-alt.md

@@ -1,25 +1,27 @@
 # DockerHub Alternatives
 
-In this section, we will discuss some popular alternatives to DockerHub. These alternatives provide a different set of features and functionalities that may suit your container registry needs. Knowing these options will enable you to make a more informed decision when selecting a container registry for your Docker images.
+These alternatives provide a different set of features and functionalities that may suit your container registry needs.
 
-### Quay.io
+## Artifact Registry
 
-[Quay.io](https://quay.io/) by Red Hat is a popular alternative to DockerHub that offers both free and paid plans. It provides an advanced security feature called "Container Security Scanning," which checks for vulnerabilities in the images stored in your repository. Quay.io also provides features like automated builds, fine-grained user access control, and Git repository integration.
+Artifact Registry is a container registry service provided by Google Cloud Platform (GCP). It offers a fully managed, private Docker container registry that integrates with other GCP services like Cloud Build, Cloud Run, and Kubernetes Engine.
-
-### Artifact Registry
-
-[Artifact Registry](https://cloud.google.com/artifact-registry) is a container registry service provided by Google Cloud Platform (GCP). It offers a fully managed, private Docker container registry that integrates with other GCP services like Cloud Build, Cloud Run, and Kubernetes Engine. Artifact Registry provides features like vulnerability scanning, access control, and artifact versioning.
 
 ### Amazon Elastic Container Registry (ECR)
 
-[Amazon Elastic Container Registry (ECR)](https://aws.amazon.com/ecr/) is a fully-managed Docker container registry by Amazon Web Services (AWS) that simplifies the process of storing, managing, and deploying Docker images. With ECR, you can control access to your images using AWS Identity and Access Management (IAM) policies. ECR also integrates with other AWS services, such as Lambda, Amazon ECS, and ECR image scanning.
+Amazon Elastic Container Registry (ECR) is a fully-managed Docker container registry by Amazon Web Services (AWS) that simplifies the process of storing, managing, and deploying Docker images.
 
 ### Azure Container Registry (ACR)
 
-[Azure Container Registry (ACR)](https://azure.microsoft.com/en-us/services/container-registry/) is Microsoft Azure's container registry offering. It provides a wide range of functionalities, including geo-replication for high availability, ACR Tasks for automated image building, container scanning for vulnerabilities, and integration with Azure Pipelines for CI/CD. ACR also offers private network access using Virtual Networks and Firewalls.
+Azure Container Registry (ACR) is Microsoft Azure's container registry offering. It provides a wide range of functionalities, including geo-replication for high availability.
 
 ### GitHub Container Registry (GHCR)
 
-[GitHub Container Registry (GHCR)](https://docs.github.com/en/packages/guides/about-github-container-registry) is the container registry service provided by GitHub. It enhances the support for Docker in GitHub Packages by providing a more streamlined experience for managing and deploying Docker images. GHCR provides fine-grained access control, seamless integration with GitHub Actions, and support for storing both public and private images.
+GitHub Container Registry (GHCR) is the container registry service provided by GitHub. It enhances the support for Docker in GitHub Packages by providing a more streamlined experience for managing and deploying Docker images.
+
+Visit the following resources to learn more:
 
-In conclusion, there are several DockerHub alternatives available, each with different features and capabilities. The choice of a container registry should be based on your requirements, such as security, scalability, cost-efficiency, or integration with other services. By exploring these options, you can find the most suitable container registry for your project.
+- [@official@DockerHub](https://hub.docker.com/)
+- [@official@Artifact Registry](https://cloud.google.com/artifact-registry)
+- [@official@Amazon ECR](https://aws.amazon.com/ecr/)
+- [@official@Azure Container Registry](https://azure.microsoft.com/en-in/products/container-registry)
+- [@official@GitHub Container Registry](https://docs.github.com/en/packages/guides/about-github-container-registry)

src/data/roadmaps/docker/content/107-container-registries/102-image-tagging-best-practices.md

@@ -4,7 +4,7 @@ Properly tagging your Docker images is crucial for efficient container managemen
 
 ## Use Semantic Versioning
 
-When tagging your image, it is recommended to follow [Semantic Versioning guidelines](https://semver.org/). Semantic versioning is a widely recognized method that can help better maintain your application. Docker image tags should have the following structure `<major_version>.<minor_version>.<patch>`. Example: `3.2.1`.
+When tagging your image, it is recommended to follow Semantic Versioning guidelines. Semantic versioning is a widely recognized method that can help better maintain your application. Docker image tags should have the following structure `<major_version>.<minor_version>.<patch>`. Example: `3.2.1`.
 
 ## Tag the Latest Version
 
@@ -14,24 +14,12 @@ Docker allows you to tag an image as 'latest' in addition to a version number. I
 docker build -t your-username/app-name:latest .
 ```
 
-## Be Descriptive and Consistent
-
-Choose clear and descriptive tag names that convey the purpose of the image or changes from the previous version. Your tags should also be consistent across your images and repositories for better organization and ease of use.
-
-## Include Build and Git Information (Optional)
-
-In some situations, it might be helpful to include information about the build and Git commit in the image tag. This can help identify the source code and environment used for building the image. Example: `app-name-1.2.3-b567-d1234efg`.
-
-## Use Environment and Architecture-Specific Tags
-
-If your application is deployed in different environments (production, staging, development) or has multiple architectures (amd64, arm64), you can use tags that specify these variations. Example: `your-username/app-name:1.2.3-production-amd64`.
-
-## Retag Images When Needed
-
-Sometimes, you may need to retag an image after it has been pushed to the registry. For example, if you have released a patch for your application, you may want to retag the new patched version with the same tag as the previous version. This allows for smoother application updates and less manual work for users who need to apply the patch.
-
 ## Use Automated Build and Tagging Tools
 
 Consider using CI/CD tools (Jenkins, GitLab CI, Travis-CI) to automate image builds and tagging based on commits, branches, or other rules. This ensures consistency and reduces the likelihood of errors caused by manual intervention.
 
-By following these best practices for image tagging, you can ensure a more organized, maintainable, and user-friendly container registry for your Docker images.
+Visit the following resources to learn more:
+
+- [@official@Docker Tags](https://docs.docker.com/get-started/docker-concepts/building-images/build-tag-and-publish-an-image/)
+- [@article@Docker Image Tagging Best Practices](https://medium.com/@nirmalkushwah08/docker-image-tagging-strategy-4aa886fb4fcc)
+- [@article@Semantic Versioning](https://semver.org/)

src/data/roadmaps/docker/content/107-container-registries/index.md

@@ -10,4 +10,10 @@ Below is a list of popular container registries available today:
 
 - **Amazon Elastic Container Registry (ECR)**: Amazon ECR is a fully-managed Docker container registry provided by Amazon Web Services, offering high scalability and performance for storing, managing, and deploying container images.
 
-- **Azure Container Registry (ACR)**: ACR is a managed registry provided by Microsoft Azure, offering Geo-replication, access control, and integration with other Azure services.
+Visit the following resources to learn more:
+
+- [@official@Docker Registry](https://docs.docker.com/registry/)
+- [@official@Docker Hub](https://hub.docker.com/)
+- [@official@Artifact Registry](https://cloud.google.com/artifact-registry)
+- [@official@Amazon ECR](https://aws.amazon.com/ecr/)
+- [@official@Azure Container Registry](https://azure.microsoft.com/en-in/products/container-registry)

src/data/roadmaps/docker/content/108-running-containers/100-docker-run.md

@@ -1,6 +1,6 @@
-# Running Containers with `docker run`
+# Running Containers
 
-In this section, we'll discuss the `docker run` command, which enables you to run Docker containers. The `docker run` command creates a new container from the specified image and starts it. 
+The `docker run` command creates a new container from the specified image and starts it.
 
 The basic syntax for the `docker run` command is as follows:
 
@@ -13,16 +13,6 @@ docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
 - `COMMAND`: This is the command that will be executed inside the container when it starts. If not specified, the default entrypoint of the image will be used.
 - `ARG...`: These are optional arguments that can be passed to the command being executed.
 
-## Commonly used Options
-
-Here are some commonly used options with `docker run`:
-
-- `--name`: Assign a name to the container, making it easier to identify and manage.
-- `-p, --publish`: Publish a container's port(s) to the host. This is useful when you want to access the services running inside the container from outside the container.
-- `-e, --env`: Set environment variables inside the container. You can use this option multiple times to set multiple variables.
-- `-d, --detach`: Run the container in detached mode, running the container in the background and not showing logs in the console.
-- `-v, --volume`: Bind mount a volume from the host to the container. This is helpful in persisting data generated by the container or sharing files between host and container.
-
 ## Examples
 
 Here are some sample commands to help you understand how to use `docker run`:
@@ -39,14 +29,6 @@ docker run -it --name=my-ubuntu ubuntu
 docker run -d --name=my-nginx -p 80:80 nginx
 ```
 
-- Run a MySQL container with custom environment variables for configuring the database:
+Visit the following resources to learn more:
 
-```bash
+- [@official@Docker Run](https://docs.docker.com/engine/reference/commandline/run/)
-docker run -d --name=my-mysql -e MYSQL_ROOT_PASSWORD=secret -e MYSQL_DATABASE=mydb -p 3306:3306 mysql
-```
-
-- Run a container with a bind-mounted volume:
-
-```bash
-docker run -d --name=my-data -v /path/on/host:/path/in/container some-image
-```

src/data/roadmaps/docker/content/108-running-containers/101-docker-compose.md

@@ -2,15 +2,7 @@
 
 Docker Compose is a tool for defining and running multi-container Docker applications. It allows you to create, manage, and run your applications using a simple YAML file called `docker-compose.yml`. This file describes your application's services, networks, and volumes, allowing you to easily run and manage your containers using just a single command.
 
-Some of the benefits of using Docker Compose include:
+## Creating a Docker Compose File
-
-- **Simplified Container Management:** Docker Compose allows you to define and configure all your services, networks, and volumes in one place, making it easy to manage and maintain.
-
-- **Reproducible Builds:** Share your `docker-compose.yml` file with others to make sure they have the same environment and services running as you do.
-
-- **Versioning Support:** Docker Compose files can be versioned for easier compatibility across different versions of the Docker Compose tool itself.
-
-## Creating a Docker Compose File:
 
 To create a `docker-compose.yml` file, start by specifying the version of Docker Compose you want to use, followed by the services you want to define. Here's an example of a basic `docker-compose.yml` file:
 
@@ -29,9 +21,9 @@ services:
       MYSQL_ROOT_PASSWORD: mysecretpassword
 ```
 
-In this example, we have specified two services: a web server (`web`) running the latest version of the nginx image, and a database server (`db`) running MySQL. The web server exposes its port 80 to the host machine and depends on the launch of the database (`db`). The database server has an environment variable set for the root password.
+The web server exposes its port 80 to the host machine and depends on the launch of the database (`db`).
 
-## Running Docker Compose:
+## Running Docker Compose
 
 To run your Docker Compose application, simply navigate to the directory containing your `docker-compose.yml` file and run the following command:
 
@@ -41,11 +33,6 @@ docker-compose up
 
 Docker Compose will read the file and start the defined services in the specified order.
 
-## Other Useful Commands:
+Visit the following resources to learn more:
-
-- `docker-compose down`: Stops and removes all running containers, networks, and volumes defined in the `docker-compose.yml` file.
-- `docker-compose ps`: Lists the status of all containers defined in the `docker-compose.yml` file.
-- `docker-compose logs`: Displays the logs of all containers defined in the `docker-compose.yml` file.
-- `docker-compose build`: Builds all images defined in the `docker-compose.yml` file.
 
-That's a brief introduction to Docker Compose! For more information, check out the official [Docker Compose documentation](https://docs.docker.com/compose/).
+- [@official@Docker Compose documentation](https://docs.docker.com/compose/).

src/data/roadmaps/docker/content/108-running-containers/102-runtime-config-options.md

@@ -1,8 +1,8 @@
 # Runtime Configuration Options
 
-Runtime configuration options allow you to customize the behavior and resources of your Docker containers when you run them. These options can be helpful in managing container resources, security, and networking. Here's a brief summary of some commonly used runtime configuration options:
+Runtime configuration options allow you to customize the behavior and resources of your Docker containers when you run them. These options can be helpful in managing container resources, security, and networking.
 
-### Resource Management
+Here's a brief summary of some commonly used runtime configuration options:
 
 - **CPU:** You can limit the CPU usage of a container with the `--cpus` and `--cpu-shares` options. `--cpus` limits the number of CPU cores a container can use, while `--cpu-shares` assigns relative share of CPU time for the container.
 
@@ -16,8 +16,6 @@ Runtime configuration options allow you to customize the behavior and resources
   docker run --memory=1G --memory-reservation=500M your-image
   ```
 
-### Security
-
 - **User:** By default, containers run as the `root` user. To increase security, you can use the `--user` option to run a container as another user or UID.
 
   ```bash
@@ -30,8 +28,6 @@ Runtime configuration options allow you to customize the behavior and resources
   docker run --read-only your-image
   ```
 
-### Networking
-
 - **Publish Ports:** You can use the `--publish` (or `-p`) option to publish a container's ports to the host system. This allows external systems to access the containerized service.
 
   ```bash
@@ -44,4 +40,6 @@ Runtime configuration options allow you to customize the behavior and resources
   docker run --hostname=my-container --dns=8.8.8.8 your-image
   ```
 
-Including these runtime configuration options will allow you to effectively manage your containers' resources, security, and networking needs. For a full list of available runtime configuration options, refer to Docker's [official documentation](https://docs.docker.com/engine/reference/run/).
+Visit the following resources to learn more:
+
+- [@official@Docker Documentation](https://docs.docker.com/engine/reference/run/)

src/data/roadmaps/docker/content/108-running-containers/index.md

@@ -12,44 +12,31 @@ For example, to run the official Nginx image, we would use:
 docker run -d -p 8080:80 nginx
 ```
 
-This starts a new container and maps the host's port 8080 to the container's port 80.
+To list all running containers, use the `docker container ls` command.
-
-## Listing Containers
-
-To list all running containers, use the `docker container ls` command. To view all containers (including those that have stopped), use the `-a` flag:
 
 ```bash
 docker container ls -a
 ```
 
-## Accessing Containers
-
 To access a running container's shell, use the `docker exec` command:
 
 ```bash
 docker exec -it CONTAINER_ID bash
 ```
 
-Replace `CONTAINER_ID` with the ID or name of your desired container. You can find this in the output of `docker container ls`.
-
-## Stopping Containers
-
 To stop a running container, use the `docker stop` command followed by the container ID or name:
 
 ```bash
 docker container stop CONTAINER_ID
 ```
 
-## Removing Containers
-
-Once a container is stopped, we can remove it using the `docker rm` command followed by the container ID or name:
-
 ```bash
 docker container rm CONTAINER_ID
 ```
 
-To automatically remove containers when they exit, add the `--rm` flag when running a container:
+Visit the following resources to learn more:
 
-```bash
+- [@official@Docker Run](https://docs.docker.com/engine/reference/commandline/run/)
-docker run --rm IMAGE
+- [@official@Docker Containers](https://docs.docker.com/engine/reference/commandline/container/)
-```
+- [@official@Docker Exec](https://docs.docker.com/engine/reference/commandline/exec/)
+- [@official@Docker Stop](https://docs.docker.com/engine/reference/commandline/stop/)

src/data/roadmaps/docker/content/109-container-security/100-image-security.md

@@ -6,28 +6,6 @@ Image security is a crucial aspect of deploying Docker containers in your enviro
 
 When pulling images from public repositories, always use trusted, official images as a starting point for your containerized applications. Official images are vetted by Docker and are regularly updated with security fixes. You can find these images on the Docker Hub or other trusted registries.
 
-* Official Images: https://hub.docker.com/explore/
-
-When downloading images from other users or creating your own, always verify the source, and inspect the Dockerfile and other provided files to ensure they follow best practices and don't introduce vulnerabilities.
-
-## Keep Images Up-to-Date
-
-Continuously monitor your images and update them regularly. This helps to minimize exposure to known vulnerabilities, as updates often contain security patches.
-
-You can use the following tools to scan and check for updates to your images:
-
-* Docker Hub: https://hub.docker.com/
-* Anchore: https://anchore.com/
-* Clair: https://github.com/quay/clair
-
-## Use Minimal Base Images
-
-A minimal base image contains only the bare essentials required to run a containerized application. The fewer components present in the base image, the smaller the attack surface for potential vulnerabilities.
-
-An example of a minimal base image is the Alpine Linux distribution, which is commonly used in Docker images due to its small footprint and security features.
-
-* Alpine Linux: https://alpinelinux.org/
-
 ## Scan Images for Vulnerabilities
 
 Regularly scan your images for known vulnerabilities using tools like Clair or Anchore. These tools can detect potential risks in your images and container configurations, allowing you to address them before pushing images to a registry or deploying them in production.
@@ -36,29 +14,7 @@ Regularly scan your images for known vulnerabilities using tools like Clair or A
 
 To ensure the integrity and authenticity of your images, always sign them using Docker Content Trust (DCT). DCT uses digital signatures to guarantee that the images you pull or push are the ones you expect and haven't been tampered with in transit.
 
-Enable DCT for your Docker environment by setting the following environment variable:
+Visit the following resources to learn more:
-
-```bash
-export DOCKER_CONTENT_TRUST=1
-```
-
-## Utilize Multi-Stage Builds
-
-Multi-stage builds allow you to use multiple `FROM` instructions within the same Dockerfile. Each stage can have a different base image or set of instructions, but only the final stage determines the final image's content. By using multi-stage builds, you can minimize the size and complexity of your final image, reducing the risk of vulnerabilities.
-
-Here's an example Dockerfile using multi-stage builds:
-
-```dockerfile
-# Build stage
-FROM node:12-alpine AS build
-WORKDIR /app
-COPY . .
-RUN npm ci --production
-
-# Final stage
-FROM node:12-alpine
-COPY --from=build /app /app
-CMD ["npm", "start"]
-```
 
-By following these best practices for image security, you can minimize the risk of vulnerabilities and ensure the safety of your containerized applications.
+- [@official@Docker Content Trust](https://docs.docker.com/engine/security/trust/content_trust/)
+- [@official@Docker Hub](https://hub.docker.com/)

src/data/roadmaps/docker/content/109-container-security/101-runtime-security.md

@@ -1,10 +1,12 @@
 # Runtime Security
 
-Runtime security focuses on ensuring the security of Docker containers while they are running in production. This is a critical aspect of container security, as threats may arrive or be discovered after your containers have been deployed. Proper runtime security measures help to minimize the damage that can be done if a vulnerability is exploited.
+Runtime security focuses on ensuring the security of Docker containers while they are running in production. This is a critical aspect of container security, as threats may arrive or be discovered after your containers have been deployed.
 
-## Least Privilege Principle
+- Ensure that your containers are regularly scanned for vulnerabilities, both in the images themselves and in the runtime environment.
+- Isolate your containers' resources, such as CPU, memory, and network, to prevent a single compromised container from affecting other containers or the host system.
+- Maintain audit logs of container activity to help with incident response, troubleshooting, and compliance.
 
-Ensure that your containers follow the principle of least privilege, meaning they should only have the minimum permissions necessary to perform their intended functions. This can help to limit the potential damage if a container is compromised.
+## Least Privilege Principle
 
 - Run your containers as a non-root user whenever possible.
 - Avoid running privileged containers, which have access to all of the host's resources.
@@ -12,30 +14,10 @@ Ensure that your containers follow the principle of least privilege, meaning the
 
 ## Read-only Filesystems
 
-By setting your containers' filesystems to read-only, you can prevent attackers from modifying critical files or planting malware inside your containers.
-
 - Use the `--read-only` flag when starting your containers to make their filesystems read-only.
 - Implement volume mounts or `tmpfs` mounts for locations that require write access.
 
-## Security Scanning and Monitoring
+Visit the following resources to learn more:
-
-Ensure that your containers are regularly scanned for vulnerabilities, both in the images themselves and in the runtime environment.
-
-- Use container scanning tools to detect and patch vulnerabilities in your images.
-- Implement runtime monitoring to detect and respond to security events, such as unauthorized access attempts or unexpected process launches.
-
-## Resource Isolation
-
-Isolate your containers' resources, such as CPU, memory, and network, to prevent a single compromised container from affecting other containers or the host system.
-
-- Use Docker's built-in resource constraints to limit the resources your containers can consume.
-- Use network segmentation and firewalls to isolate your containers and limit their communication.
-
-## Audit Logs
-
-Maintain audit logs of container activity to help with incident response, troubleshooting, and compliance.
-
-- Use Docker's logging capabilities to capture container logs, outputting them to a centralized logging solution.
-- Implement log analysis tools to monitor for suspicious activity and automatically alert if a potential incident is detected.
 
-By focusing on runtime security, you can help ensure that your Docker containers continue to be secure even after they have been deployed in your environment. Aim to minimize the potential attack surface and continuously monitor for threats to help protect your critical applications and data.
+- [@official@Docker Security](https://docs.docker.com/engine/security/)
+- [@official@Docker Security Best Practices](https://docs.docker.com/build/building/best-practices/)

src/data/roadmaps/docker/content/109-container-security/index.md

@@ -1,35 +1,16 @@
 # Container Security
 
-Container security is a critical aspect of implementing and managing container technologies like Docker. It encompasses a set of practices, tools, and technologies designed to protect containerized applications and the infrastructure they run on. In this section, we'll discuss some key container security considerations, best practices, and recommendations.
+- Container security is a critical aspect of implementing and managing container technologies like Docker. It encompasses a set of practices, tools, and technologies designed to protect containerized applications and the infrastructure they run on.
 
-## Container Isolation
+- Isolation is crucial for ensuring the robustness and security of containerized environments. Containers should be isolated from each other and the host system, to prevent unauthorized access and mitigate the potential damage in case an attacker manages to compromise one container.
 
-Isolation is crucial for ensuring the robustness and security of containerized environments. Containers should be isolated from each other and the host system, to prevent unauthorized access and mitigate the potential damage in case an attacker manages to compromise one container.
+- Implementing best practices and specific security patterns during the development, deployment, and operation of containers is essential to maintaining a secure environment.
 
-- **Namespaces**: Docker uses namespace technology to provide isolated environments for running containers. Namespaces restrict what a container can see and access in the broader system, including process and network resources.
+- Access controls should be applied to both container management and container data, in order to protect sensitive information and maintain the overall security posture.
-- **Cgroups**: Control groups (`cgroups`) are used to limit the resources consumed by containers, such as CPU, memory, and I/O. Proper use of `cgroups` aids in preventing DoS attacks and resource exhaustion scenarios.
 
-## Security Patterns and Practices
+- Containers can be vulnerable to attacks, as their images depend on a variety of packages and libraries. To mitigate these risks, vulnerability management should be included in the container lifecycle.
 
-Implementing best practices and specific security patterns during the development, deployment, and operation of containers is essential to maintaining a secure environment.
+Visit the following resources to learn more:
 
-- **Least Privilege**: Containers should be run with the least possible privilege, granting only the minimal permissions required for the application.
+- [@official@Docker Security](https://docs.docker.com/engine/security/)
-- **Immutable Infrastructure**: Containers should be treated as immutable units - once built, they should not be altered. Any change should come by deploying a new container from an updated image.
+- [@article@Kubernetes Security Best Practices](https://www.aquasec.com/cloud-native-academy/kubernetes-in-production/kubernetes-security-best-practices-10-steps-to-securing-k8s/)
-- **Version Control**: Images should be version-controlled and stored in a secure container registry.
-
-## Secure Access Controls
-
-Access controls should be applied to both container management and container data, in order to protect sensitive information and maintain the overall security posture.
-
-- **Container Management**: Use Role-Based Access Control (RBAC) to restrict access to container management platforms (e.g., Kubernetes) and ensure that users have only the minimum permissions necessary.
-- **Container Data**: Encrypt data at rest and in transit, especially when handling sensitive information.
-
-## Container Vulnerability Management
-
-Containers can be vulnerable to attacks, as their images depend on a variety of packages and libraries. To mitigate these risks, vulnerability management should be included in the container lifecycle.
-
-- **Image Scanning**: Use automated scanning tools to identify vulnerabilities in containers and images. These tools should be integrated into the development pipeline to catch potential risks before they reach production.
-- **Secure Base Images**: Use minimal and secure base images for container creation, reducing the attack surface and potential vulnerabilities.
-- **Regular Updates**: Keep base images and containers up-to-date with the latest security patches and updates.
-
-By understanding and applying these key aspects of container security, you'll be well on your way to ensuring that your containerized applications and infrastructure are protected from potential threats.

src/data/roadmaps/docker/content/110-docker-cli/100-images.md

@@ -2,9 +2,7 @@
 
 Docker images are lightweight, standalone, and executable packages that include everything needed to run an application. These images contain all necessary dependencies, libraries, runtime, system tools, and code to enable the application to run consistently across different environments.
 
-Docker images are built and managed using Dockerfiles. A Dockerfile is a script that consists of instructions to create a Docker image, providing a step-by-step guide for setting up the application environment.
+## Working with Docker Images
-
-### Working with Docker Images
 
 Docker CLI provides several commands to manage and work with Docker images. Some essential commands include:
 
@@ -20,28 +18,6 @@ For example, to pull the official Ubuntu image from Docker Hub, you can run the
 docker pull ubuntu:latest
 ```
 
-After pulling the image, you can create and run a container using that image with the `docker run` command:
-
-```bash
-docker run -it ubuntu:latest /bin/bash
-```
-
-This command creates a new container and starts an interactive session inside the container using the `/bin/bash` shell.
-
 ## Sharing Images
 
 Docker images can be shared and distributed using container registries, such as Docker Hub, Google Container Registry, or Amazon Elastic Container Registry (ECR). Once your images are pushed to a registry, others can easily access and utilize them.
-
-To share your image, you first need to tag it with a proper naming format:
-
-```bash
-docker tag <image-id> <username>/<repository>:<tag>
-```
-
-Then, you can push the tagged image to a registry using:
-
-```bash
-docker push <username>/<repository>:<tag>
-```
-
-In conclusion, Docker images are a crucial part of the Docker ecosystem, allowing developers to package their applications, share them easily, and ensure consistency across different environments. By understanding Docker images and the commands to manage them, you can harness the power of containerization and enhance your development workflow.

src/data/roadmaps/docker/content/110-docker-cli/101-containers.md

@@ -2,18 +2,6 @@
 
 Containers can be thought of as lightweight, stand-alone, and executable software packages that include everything needed to run a piece of software, including the code, runtime, libraries, environment variables, and config files. Containers isolate software from its surroundings, ensuring that it works uniformly across different environments.
 
-## Why Use Containers?
-
-- **Portability**: Containers ensure that applications work consistently across different platforms, be it a developer's laptop or a production server. This eliminates the "it works on my machine" problem.
-
-- **Efficiency**: Containers are lightweight since they use shared resources without the overhead of a full-fledged operating system. This enables faster startup times and reduces resource usage.
-
-- **Scalability**: Containers can be effortlessly scaled up or down according to the workload, making it ideal for distributed applications and microservices.
-
-- **Consistency**: Containers enable developers, QA, and operations teams to have a consistent environment throughout the application lifecycle, leading to faster and smoother deployment pipelines.
-
-- **Security**: Containers provide a level of isolation from other containers and the underlying host system, which aids in maintaining application security.
-
 ## Working with Containers using Docker CLI
 
 Docker CLI offers several commands to help you create, manage, and interact with containers. Some common commands include:
@@ -29,3 +17,8 @@ Docker CLI offers several commands to help you create, manage, and interact with
 - `docker exec`: Executes a command inside a running container.
 
 - `docker logs`: Fetches the logs of a container, useful for debugging issues.
+
+Visit the following resources to learn more:
+
+- [@official@Docker CLI Commands](https://docs.docker.com/engine/reference/commandline/cli/)
+- [@article@Docker CLI Commands Cheat Sheet](https://www.docker.com/blog/docker-cli-commands-cheat-sheet/)

src/data/roadmaps/docker/content/110-docker-cli/102-networks.md

@@ -2,15 +2,6 @@
 
 Docker networks provide an essential way of managing container communication. It allows containers to talk to each other and to the host machine using various network drivers. By understanding and utilizing different types of network drivers, you can design container networks to accommodate specific scenarios or application requirements.
 
-### Network Drivers
-
-There are several network drivers available in Docker. Here, we will cover four of the most common ones:
-
-- **bridge**: The default network driver for containers. It creates a private network where containers can communicate with each other and the host machine. Containers on this network can access external resources via the host's network.
-- **host**: This driver removes network isolation and allows containers to share the host's network. It is useful for cases where network performance is crucial, as it minimizes the overhead of container networking.
-- **none**: This network driver disables container networking. Containers using this driver run in an isolated environment without any network access.
-- **overlay**: This network driver enables containers deployed on different hosts to communicate with each other. It is designed to work with Docker Swarm and is perfect for multi-host or cluster-based container deployments.
-
 ## Managing Docker Networks
 
 Docker CLI provides various commands to manage the networks. Here are a few useful commands:
@@ -21,3 +12,8 @@ Docker CLI provides various commands to manage the networks. Here are a few usef
 - Connect containers to a network: `docker network connect <network_name> <container_name>`
 - Disconnect containers from a network: `docker network disconnect <network_name> <container_name>`
 - Remove a network: `docker network rm <network_name>`
+
+Visit the following resources to learn more:
+
+- [@official@Docker Networks](https://docs.docker.com/network/)
+- [@official@Docker Network Commands](https://docs.docker.com/engine/reference/commandline/network/)

src/data/roadmaps/docker/content/110-docker-cli/102-volumes.md

@@ -2,18 +2,13 @@
 
 Docker volumes are a mechanism for persisting data generated by and used by Docker containers. They allow you to separate the data from the container itself, making it easy to backup, migrate, and manage your persistent data.
 
-## Why Volumes are Important
-
-Docker containers are ephemeral by nature, meaning they can be stopped, deleted, or replaced easily. While this is great for application development and deployment, it poses a challenge when dealing with persistent data. That's where volumes come in. They provide a way to store and manage the data separately from the container's lifecycle.
-
 ## Types of Volumes
 
 There are three types of volumes in Docker:
-- **Host Volumes**: They are stored on the host machine's filesystem, usually in the `/var/lib/docker/volumes` directory. These can be easily accessed, but can pose issues with portability or file system compatibility.
 
-- **Anonymous Volumes**: These are created automatically when a container is run without specifying a volume. Their ID is generated by Docker and they are also stored on the host machine's filesystem.
+- **Host Volumes**
-
+- **Anonymous Volumes**
-- **Named Volumes**: Similar to anonymous volumes, named volumes are stored on the host machine's filesystem. However, you can provide a custom name, making it easy to reference in other containers or for backups.
+- **Named Volumes**
 
 ## Volume Management with Docker CLI
 
@@ -31,4 +26,7 @@ To use a volume in a container, you can use the `-v` or `--volume` flag during t
 docker run -d --name my-container -v my-named-volume:/var/lib/data my-image
 ```
 
-This command creates a new container named "my-container" using the "my-image" image and mounts the "my-named-volume" volume at the `/var/lib/data` path inside the container.
+Visit the following resources to learn more:
+
+- [@official@Docker Volumes](https://docs.docker.com/storage/volumes/)
+- [@official@Docker Volume Commands](https://docs.docker.com/engine/reference/commandline/volume/)

src/data/roadmaps/docker/content/110-docker-cli/index.md

@@ -37,54 +37,11 @@ Here are some essential Docker CLI commands to familiarize yourself with:
 
 A Dockerfile is a script containing instructions to build a Docker image. You can use the Docker CLI to build, update, and manage Docker images using a Dockerfile.
 
-Here is a simple example of a Dockerfile:
-
-```dockerfile
-# Set the base image to use
-FROM alpine:3.7
-
-# Update the system and install packages
-RUN apk update && apk add curl
-
-# Set the working directory
-WORKDIR /app
-
-# Copy the application file
-COPY app.sh .
-
-# Set the entry point
-ENTRYPOINT ["./app.sh"]
-```
-
-To build the image, use the command:
-
-```bash
-docker build -t my-image .
-```
-
 ## 5. Docker Compose
 
 Docker Compose is a CLI tool for defining and managing multi-container Docker applications using YAML files. It works together with the Docker CLI, offering a consistent way to manage multiple containers and their dependencies.
 
-Install Docker Compose using the official [installation guide](https://docs.docker.com/compose/install/), and then you can create a `docker-compose.yml` file to define and run multi-container applications:
+Visit the following resources to learn more:
-
-```yaml
-version: '3'
-services:
-  web:
-    image: webapp-image
-    ports:
-      - "80:80"
-  database:
-    image: mysql
-    environment:
-      - MYSQL_ROOT_PASSWORD=my-secret-pw
-```
-
-Run the application using the command:
-
-```bash
-docker-compose up
-```
 
-In conclusion, the Docker CLI is a robust and versatile tool for managing all aspects of Docker containers and resources. Once familiar with its commands and capabilities, you'll be well-equipped to develop, maintain and deploy applications using Docker with ease.
+- [@official@Docker CLI](https://docs.docker.com/reference/cli/docker/)
+- [@official@Docker Compose](https://docs.docker.com/compose/)

src/data/roadmaps/docker/content/111-developer-experience/101-debuggers.md

@@ -2,4 +2,7 @@
 
 In order to make developing with containers competitive with developing locally, we need the ability to run and attach to debuggers inside the container.
 
+Visit the following resources to learn more:
+
+- [@official@Docker Buildx Debug](https://docs.docker.com/reference/cli/docker/buildx/debug/)
 - [@article@Debuggers in Docker](https://courses.devopsdirective.com/docker-beginner-to-pro/lessons/11-development-workflow/02-debug-and-test)

src/data/roadmaps/docker/content/111-developer-experience/102-tests.md

@@ -2,5 +2,7 @@
 
 We want to run tests in an environment as similar as possible to production, so it only makes sense to do so inside of our containers!
 
+Visit the following resources to learn more:
+
 - [@article@Running Tests - Docker](https://courses.devopsdirective.com/docker-beginner-to-pro/lessons/11-development-workflow/03-tests)
 - [@feed@Explore top posts about Testing](https://app.daily.dev/tags/testing?ref=roadmapsh)

src/data/roadmaps/docker/content/111-developer-experience/103-continuous-integration.md

@@ -10,7 +10,7 @@ For containers, there are a number of things we may want to do:
 - Tag images with useful metadata
 - Push to a container registry
 
-Learn more from the following:
+Visit the following resources to learn more:
 
 - [@article@Continuous Integration - Docker](https://courses.devopsdirective.com/docker-beginner-to-pro/lessons/11-development-workflow/04-continuous-integration-github-actions)
 - [@feed@Explore top posts about CI/CD](https://app.daily.dev/tags/cicd?ref=roadmapsh)

src/data/roadmaps/docker/content/111-developer-experience/index.md

@@ -13,3 +13,4 @@ So far we have only discussed using docker for deploying applications. However,
 For more details and practical examples:
 
 - [@article@Developer Experience Wishlist - Docker](https://courses.devopsdirective.com/docker-beginner-to-pro/lessons/11-development-workflow/00-devx-wishlist#key-devx-features)
+- [@official@Docker Developer Experience](https://www.docker.com/blog/cto-chat-overcoming-the-developer-experience-gap-feat-redmonk-flow-io/)

src/data/roadmaps/docker/content/112-deploying-containers/100-paas-options.md

@@ -4,47 +4,24 @@ Platform as a Service (PaaS) is a cloud computing model that simplifies the depl
 
 ## Amazon Elastic Container Service
 
-[Amazon Elastic Container Service](https://aws.amazon.com/ecs/) is a fully managed container orchestration service offered by Amazon Web Services. It allows you to run containers without having to manage servers or clusters. It integrates with other AWS services such as IAM, CloudWatch, and CloudFormation.
+is a fully managed container orchestration service offered by Amazon Web Services. It allows you to run containers without having to manage servers or clusters.
-
-- Supports Docker containers and Amazon ECR
-- Offers a free tier for new users
-- Supports multiple deployment options
-- Pay for what you use, with no upfront costs
 
 ## Google Cloud Run
 
-[Google Cloud Run](https://cloud.google.com/run) is a fully-managed compute platform by Google that allows you to run stateless containers. It is designed for running applications that can scale automatically, enabling you to pay only for the resources you actually use.
+Google Cloud Run is a fully-managed compute platform by Google that allows you to run stateless containers. It is designed for running applications that can scale automatically, enabling you to pay only for the resources you actually use.
-
-- Automatically scales based on demand
-- Supports custom domains and TLS certificates
-- Integrates with other Google Cloud services
-- Offers a generous free tier
 
-## AWS Elastic Beanstalk
+## IBM Cloud Code Engine
-
-[AWS Elastic Beanstalk](https://aws.amazon.com/elasticbeanstalk/) is an orchestration service offered by Amazon Web Services that allows you to deploy, manage, and scale applications using containers, without worrying about the underlying infrastructure.
 
-- Supports multiple languages and platforms, including Docker containers
+IBM Cloud Code Engine is a fully managed, serverless platform by IBM that runs your containerized applications and source code. It supports deploying, running, and auto-scaling applications on Kubernetes.
-- Integration with other AWS services, such as RDS, S3, and CloudFront
-- Offers monitoring and logging capabilities
-- Pay for what you use, with no upfront costs
 
 ## Microsoft Azure Container Instances
 
-[Azure Container Instances](https://azure.microsoft.com/en-us/services/container-instances/) is a service offered by Microsoft Azure that simplifies the deployment of containers using a serverless model. You can run containers without managing the underlying hosting infrastructure or container orchestration.
+Microsoft Azure Container Instances is a service offered by Microsoft Azure that simplifies the deployment of containers using a serverless model. You can run containers without managing the underlying hosting infrastructure or container orchestration.
-
-- Fast and simple deployment process
-- Customizable size, network, and storage configurations
-- Integration with Azure services and Azure Kubernetes Service
-- Pay-per-second billing model
-
-## IBM Cloud Code Engine
-
-[IBM Cloud Code Engine](https://www.ibm.com/cloud/code-engine) is a fully managed, serverless platform by IBM that runs your containerized applications and source code. It supports deploying, running, and auto-scaling applications on Kubernetes.
 
-- Built on top of Kubernetes and Knative
+Visit the following resources to learn more:
-- Deploy from your container registry or source code repository
-- Supports event-driven and batch workloads
-- Pay-as-you-go model
 
-When choosing a PaaS option for deploying containers, consider factors such as integration with existing tools, ease of use, costs, scalability, and support for the programming languages and frameworks your team is familiar with. Regardless of your choice, PaaS options make it easy for developers to deploy applications without worrying about managing and maintaining the underlying infrastructure.
+- [@official@PaaS Options for Deploying Containers](https://www.docker.com/resources/what-container/#paas-options)
+- [@official@Azure Container Instances](https://azure.microsoft.com/en-us/services/container-instances/)
+- [@official@Google Cloud Run](https://cloud.google.com/run)
+- [@official@IBM Cloud Code Engine](https://www.ibm.com/cloud/code-engine)
+- [@official@Amazon Elastic Container Service](https://aws.amazon.com/ecs/)

src/data/roadmaps/docker/content/112-deploying-containers/101-kubernetes.md

@@ -14,17 +14,11 @@ Kubernetes (K8s) is an open-source orchestration platform used for automating th
 
 - **Deployment**: A high-level object that describes the desired state of a containerized application. Deployments manage the process of creating, updating, and scaling pods based on a specified container image.
 
-## Why Use Kubernetes?
-
-Kubernetes plays a crucial role in managing containerized applications at scale, offering several advantages over traditional deployment mechanisms:
-
-- **Scalability**: By automatically scaling the number of running containers based on resource usage and application demands, Kubernetes ensures optimal resource utilization and consistent app performance.
-- **Self-healing**: Kubernetes continuously monitors the health of your containers and replaces failed pods to maintain the desired application state.
-- **Rolling updates & rollbacks**: Kubernetes makes it easy to update your applications by incrementally rolling out new versions of container images, without any downtime.
-- **Load balancing**: Services in Kubernetes distribute network traffic among container instances, offering a load balancing solution for your applications.
-
 ## Kubernetes vs. Docker Swarm
 
 While both Kubernetes and Docker Swarm are orchestration platforms, they differ in terms of complexity, scalability, and ease of use. Kubernetes provides more advanced features, better scalability, and higher fault tolerance, but has a steeper learning curve. Docker Swarm, on the other hand, is simpler and more straightforward but lacks some advanced functionality.
 
-In the context of these differences, selecting the right orchestration platform depends on the needs and requirements of your project.
+Visit the following resources to learn more:
+
+- [@official@Kubernetes](https://kubernetes.io/)
+- [@official@Docker Swarm](https://docs.docker.com/engine/swarm/)

src/data/roadmaps/docker/content/112-deploying-containers/102-docker-swarm.md

@@ -2,15 +2,7 @@
 
 Docker Swarm is a container orchestration tool that enables users to manage multiple Docker nodes and deploy services across them. It is a native clustering and orchestration feature built into the Docker Engine, which allows you to create and manage a swarm of Docker nodes, referred to as a _Swarm_.
 
-## Key concepts
+## Advantages
-
-- **Node**: A Docker node is an instance of the Docker Engine that participates in the swarm. Nodes can either be a _worker_ or a _manager_. Worker nodes are responsible for running containers whereas manager nodes control the swarm and store the necessary metadata.
-
-- **Services**: A service is a high-level abstraction of the tasks required to run your containers. It defines the desired state of a collection of containers, specifying the Docker image, desired number of replicas, and required ports.
-
-- **Tasks**: A task carries a Docker container and the commands required to run it. Swarm manager nodes assign tasks to worker nodes based on the available resources.
-
-## Main advantages
 
 - **Scalability**: Docker Swarm allows you to scale services horizontally by easily increasing or decreasing the number of replicas.
 
@@ -20,4 +12,6 @@ Docker Swarm is a container orchestration tool that enables users to manage mult
 
 - **Rolling updates**: Swarm enables you to perform rolling updates with near-zero downtime, easing the process of deploying new versions of your applications.
 
-Visit the official [Docker Swarm documentation](https://docs.docker.com/engine/swarm/) to learn more about its features and best practices.
+Visit the following resources to learn more:
+
+- [@official@Docker Swarm](https://docs.docker.com/engine/swarm/)

src/data/roadmaps/docker/content/112-deploying-containers/103-nomad.md

@@ -1,5 +1,7 @@
 # Nomad: Deploying Containers
 
-Nomad is a cluster manager and scheduler that enables you to deploy, manage and scale your containerized applications. It automatically handles node failures, resource allocation, and container orchestration. Nomad supports running Docker containers as well as other container runtimes and non-containerized applications.
+Nomad is a cluster manager and scheduler that enables you to deploy, manage and scale your containerized applications. It automatically handles node failures, resource allocation, and container orchestration. Nomad supports running Docker containers as well as other container runtime(s) and non-containerized applications.
 
-To dive deeper into Nomad, check out the [official documentation](https://www.nomadproject.io/docs).
+Visit the following resources to learn more:
+
+- [@official@Nomad Documentation](https://www.nomadproject.io/docs)

src/data/roadmaps/docker/content/112-deploying-containers/index.md

@@ -2,37 +2,24 @@
 
 Deploying containers is a crucial step in using Docker and containerization to manage applications more efficiently, easily scale, and ensure consistent performance across environments. This topic will give you an overview of how to deploy Docker containers to create and run your applications.
 
-## Overview
-
-Docker containers are lightweight, portable, and self-sufficient environments that can run applications and their dependencies. Deploying containers involves starting, managing, and scaling these isolated environments in order to run your applications smoothly.
-
 ## Benefits of Container Deployment
 
-- **Consistency**: Containers enable your application to run in the same way across various environments, avoiding the common "it works on my machine" issue.
+- **Consistency**: Containers ensure your application runs the same way across different environments, solving the "it works on my machine" issue.
-- **Isolation**: Each container runs in an isolated environment, avoiding conflicts with other applications and ensuring that each service can be independently managed.
+- **Isolation**: Each container operates independently, avoiding conflicts and allowing better service management.
-- **Scalability**: Containers make it easy to scale applications by running multiple instances and distributing the workload among them.
+- **Scalability**: Easily scale applications by running multiple instances and distributing the workload.
-- **Version Control**: Deploying containers helps you manage different versions of your application, allowing you to easily roll back to previous versions if needed.
+- **Version Control**: Manage different versions and roll back to previous versions if needed.
-
-## Key Concepts
-
-- **Image**: A Docker image is a lightweight, standalone, executable package that contains everything needed to run a piece of software, including the code, runtime, system tools, libraries, and settings.
-- **Container**: A Docker container is a running instance of a Docker image. You can deploy multiple containers from the same image, each running independently.
-- **Docker Registry**: A place where Docker images are stored and retrieved. Docker Hub is the default registry used by Docker, but you can use your own private registry if desired.
 
 ## Steps to Deploy Containers
 
-- **Create a Dockerfile**: A Dockerfile is a script with instructions to build a Docker image. It should specify the base image, application code, dependencies, and configurations needed to run your application.
+- **Create a Dockerfile**: Script that defines the image with base image, code, dependencies, and configurations.
-
+- **Build the Docker Image**: Use `docker build` to create an image from the Dockerfile.
-- **Build the Docker Image**: Using the Docker client, you can build a new image by running `docker build` and specifying the path to your Dockerfile. This will create a new Docker image based on the instructions in your Dockerfile.
+- **Push the Docker Image**: Push the image to a registry using `docker push`.
-
+- **Deploy the Container**: Use `docker run` to start a container from the image.
-- **Push the Docker Image**: After building the image, you must push it to a registry (e.g., Docker Hub) so that it can be easily retrieved when deploying containers. Use the `docker push` command followed by the image name and tag.
+- **Manage the Container**: Use commands like `docker ps`, `docker stop`, and `docker rm` for container management.
-
+- **Monitor and Log**: Use `docker logs` for log viewing and `docker stats` for performance monitoring.
-- **Deploy the Container**: To deploy a new container from the Docker image, use the `docker run` command followed by the image name and tag. This will start a new container and execute the required application.
-
-- **Manage the Container**: Deployment involves ensuring the container is running properly and managing scaling, updates, and other key aspects. Use Docker commands like `docker ps` (to list running containers), `docker stop` (to stop a container), and `docker rm` (to remove a container) to manage your deployed containers.
-
-- **Monitor and Log**: Collect logs and monitor the performance of your deployed containers to ensure they are running optimally. Use commands like `docker logs` (to view logs) and `docker stats` (to see container statistics) as needed.
 
-## Conclusion
+Visit the following resources to learn more:
 
-Deploying containers with Docker allows you to improve application consistency, security, and scalability while simplifying management and reducing the overhead typically associated with deployment. By understanding the concepts and steps outlined in this guide, you'll be well-equipped to deploy your applications using Docker containers.
+- [@official@Docker Deployment](https://docs.docker.com/get-started/deployment/)
+- [@official@Docker Compose](https://docs.docker.com/compose/)
+- [@official@Docker Swarm](https://docs.docker.com/engine/swarm/)

src/data/roadmaps/docker/content/index.md

@@ -1 +1 @@
-# 
+