update ToC

Author: khalid-el-masnaoui

DOCKERFILE.md

@@ -65,7 +65,7 @@ In the example above, each instruction creates one layer:
 - `RUN` builds your application with `make`.
 - `CMD` specifies what command to run within the container.
 
-**Note** : When you run an image and generate a container, you add a new _writable layer_, also called the container layer, on top of the underlying layers. All changes made to the running container, such as writing new files, modifying existing files, and deleting files, are written to this writable container layer (writable layer is not persistent,  [read about that here](README.md#volumes-card_file_box) ).
+**Note** : When you run an image and generate a container, you add a new _writable layer_, also called the container layer, on top of the underlying layers. All changes made to the running container, such as writing new files, modifying existing files, and deleting files, are written to this writable container layer (writable layer is not persistent,  [read about that here](docker/Notes/README.md#volumes-card_file_box) ).
 
 
 ## Dockerfile Instructions Reference
@@ -266,7 +266,7 @@ _Multi-stage builds_ allow us to create a Dockerfile that defines multiple stag
 
 The key advantage of using multi-stage builds is that it allows developers to reduce the size of the final image. By breaking down the build process into smaller stages, it becomes easier to remove unnecessary files and dependencies that are not needed in the final image. This can significantly reduce the size of the image, which can lead to faster deployment times and lower storage costs.
 
-In addition to reducing image size, multi-stage builds can also improve build performance. By breaking down the build process into smaller stages, Docker can cache the intermediate images and reuse them if the source code or dependencies haven't changed. This can lead to faster builds and shorter development cycles. [Read about docker best practices here](BEST-PRACTICES.md)
+In addition to reducing image size, multi-stage builds can also improve build performance. By breaking down the build process into smaller stages, Docker can cache the intermediate images and reuse them if the source code or dependencies haven't changed. This can lead to faster builds and shorter development cycles. [Read about docker best practices here](docker/Notes/BEST-PRACTICES.md)
 
 ##### Use multi-stage builds
 

README.md

@@ -1,13 +1,22 @@
 # Docker Notes
+
+```
+  ____             _             
+ |  _ \  ___   ___| | _____ _ __ 
+ | | | |/ _ \ / __| |/ / _ \ '__|
+ | |_| | (_) | (__|   <  __/ |   
+ |____/ \___/ \___|_|\_\___|_|   
+                                 
+```
 A cheat-sheets and quick but relatively-detailed reference guide for _docker CLI_ commands and some of docker concepts
 
 This repository containes a complete _**set**_ of DOCKER NOTES organized as follow:
 
-- [Docker Architecture](ARCHITECTURE.md) 
-- [Docker CLI ](README.md) (_current file_)
+- [Docker Architecture](docker/Notes/ARCHITECTURE.md) 
+- [Docker CLI ](docker/Notes/README.md) (_current file_)
 - [Dockerfile](DOCKERFILE.md)
 - [Docker Compose](DOCKER-COMPOSE.md)
-- [Docker Best Practices](BEST-PRACTICES.md)
+- [Docker Best Practices](docker/Notes/BEST-PRACTICES.md)
 
 # Table Of Contents
 
@@ -26,6 +35,7 @@ This repository containes a complete _**set**_ of DOCKER NOTES organized as foll
 	- **[Docker Logs Rotation Configuration](#docker-logs-rotation-configuration)**
 - **[Volumes](#volumes-card_file_box)**
     - **[The Docker File System](#the-docker-file-system)**
+    - **[Persistent data with volumes](#[persistent-data-with-volumes)**
     - **[Creating and managing a volume](#creating-and-managing-a-volume)**
     - **[Usage](#usage)**
 		- **[Starting a Container with a Volume](#starting-a-container-with-a-volume)**
@@ -58,7 +68,7 @@ $ docker info #Display system-wide information
 ## Images :framed_picture:
 Images are read-only templates containing instructions for creating a container. A Docker image creates containers to run on the Docker platform.
 Think of an image like a blueprint or snapshot of what will be in a container when it runs.
-[discover-docker-images-and-containers-concepts-here](ARCHITECTURE.md)
+[discover-docker-images-and-containers-concepts-here](docker/Notes/ARCHITECTURE.md)
 ##### Download an image from a registry (Such as Docker Hub)
 ```bash
 $ docker pull image
@@ -121,7 +131,7 @@ $ docker image inspect [ID/NAME]  #Display detailed information on one or more i
 
 ## Containers :ship:
 A container is an isolated place where an application runs without affecting the rest of the system and without the system impacting the application. 
-[discover-docker-images-and-containers-concepts-here](ARCHITECTURE.md)
+[discover-docker-images-and-containers-concepts-here](docker/Notes/ARCHITECTURE.md)
 ##### Create and run a new container from an image
 ```bash
 docker run --name NAME --rm -itd -p PORTS  --net=<custom_net> --ip=IP image COMMAND
@@ -280,6 +290,20 @@ So, any file change inside the container creates a working copy in the read-writ
 <img src="https://www.baeldung.com/wp-content/uploads/2021/01/layers.png"/>
 </p>
 
+How layers are created:
+
+- **Dockerfile Instructions:** Every command or instruction in a Dockerfile, such as `FROM`, `RUN`, `COPY`, `ADD`, `WORKDIR`, `EXPOSE`, `ENV`, `VOLUME`, `USER`, `ARG`, `ONBUILD`, `STOPSIGNAL`, `HEALTHCHECK`, `SHELL`, and `CMD`, contributes to the image's layers or metadata.
+    - **Filesystem-modifying instructions:** Instructions like `RUN`, `COPY`, and `ADD` create new layers that capture the changes made to the image's filesystem. For example, `RUN apt-get update` would create a layer containing the updated package lists.
+    - **Metadata instructions:** Instructions like `EXPOSE`, `ENV`, `LABEL`, `ENTRYPOINT`, and `CMD` don't directly modify the filesystem but add metadata to the image, which is also associated with a layer.
+- **Base Image:**  The `FROM` instruction in a Dockerfile specifies a base image, which itself is composed of a stack of existing layers. These base image layers form the foundation upon which your custom layers are built.
+
+- **Caching:**  Docker leverages layer caching during the build process. If an instruction and its inputs haven't changed since a previous build, Docker can reuse the existing cached layer, making builds faster and more efficient. **A change in one layer, however, will trigger the recreation of that layer and all subsequent layers**.
+
+
+##### Persistent Data with volumes 
+
+Docker uses volumes/mounts to persist data beyond container lifecycles. Files written to a volume are saved outside the container, even after deletion.
+
 When it comes to storing persistent docker container data , we have three options **Volumes**,  **Bind Mounts** and **Tmpfs mounts**
 
 **Volumes** : Volumes are the preferred mechanism for persisting data generated by and used by Docker containers. A bind mount uses the host file system, but _Docker volume are native to Docker_.
@@ -425,7 +449,7 @@ $ docker run --volumes-from 4920 \
 **Note** : `--volumes-from`can be use in order to Back up, restore, or migrate data volumes.
 In practice `--volumes-from` is usually used to link volumes between running containers (volume data migration).
 
-**Note 2** : Dealing with file permissions with docker volumes can be confusing , (between the host and the container), you can read more about such topic in _docker best practices_ notes [here](BEST-PRACTICES.MD)
+**Note 2** : Dealing with file permissions with docker volumes can be confusing , (between the host and the container), you can read more about such topic in _docker best practices_ notes [here](docker/Notes/BEST-PRACTICES.md)
 
 ## Networking :earth_africa: