Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/fakhranii/docker-with-nodejs

A nodejs application which deals with docker-compose & Dockerfile
https://github.com/fakhranii/docker-with-nodejs

docker docker-compose dockerf mongodb mongoose nodejs pg postgresql

Last synced: 6 days ago
JSON representation

A nodejs application which deals with docker-compose & Dockerfile

Awesome Lists containing this project

README 

        
# ⭐ This Repo Is About Mastering Docker ⭐



## Table of Contents



1. [Start With Docker](#start-with-docker)

2. [How To Write Instructions In Dockerfile](#how-to-write-instructions-in-dockerfile)

3. [How to Deal With Docker Via Terminal Commands](#how-to-deal-with-docker-via-terminal-commands)

4. [Dockerfile Commands](#dockerfile-commands)

5. [Docker Compose](#docker-compose)

   - [Common Docker Compose Commands](#common-docker-compose-commands)

6. [Difference Between Images & Containers](#difference-between-images--containers)

   - [Docker Images](#docker-images)

   - [Docker Containers](#docker-containers)

   - [Key Differences](#key-differences)



---



## _Start With Docker_



- **The first step to start with docker is create file named `Dockerfile`.**

- **There is a helpful extension in vsc called `Docker` you have to install it, it will help you engage with docker.**

- **Once you did create an `image` you can create `container` from it.**



---



## _How To write Instructions In Dockerfile_



- **At the first `Dockerfile` is just a file to write some instructions in it, to tell `docker` how to works!, what dependencies are required in our application, how to build the application, how to run the application.**

- **`Container` is the output of running `Dockerfile`.**

- **People usually start the `Dockerfile` with this line ➡ `FROM baseImage`, `baseImage` is the thing that will give me the dependencies which my application requires, and the `baseImage` in our app is `node` so in our case we'll write `FROM node` we replaced `baseImage` with the image name which is `node` .**

- **if i wrote only `FROM node` it will give me the latest version of `node`, and i wanna specific version i should write `FROM node:14` for example.**

- **To create a `folder` inside `Dockerfile` we'll use this keyword ➡ `WORKDIR /name`.**

- **To copy a file content we'll use the keyword `COPY source dest` .. the source is the place we'll take the copy from and the dest is the place we'll past the copy in.**

- **To run a command inside `Dockerfile` ➡ `RUN command` and replace the command keyword with the command you wanna run.**

- **`EXPOSE` Define the network ports that this container will listen on at runtime .. for example `EXPOSE 3000` , its just for documentation ..**



---



## _How to Deal With `Docker` Via Terminal Commands_



- **`docker version`: Displays the Docker version installed.**



- **`docker info`: Shows detailed information about the Docker installation.**



- **`docker pull `: Downloads a Docker image from a registry.**



- **`docker build -t  `: Builds a Docker image from a Dockerfile in the specified path.**



- **`docker images`: Lists all Docker images on the local system.**



- **`docker rmi `: Removes a Docker image.**



- **`docker tag  `: Tags an image for easy reference.**



- **`docker run `: Runs a command in a new container.**



- **`docker run --name express-container -v d:\programming\projects\local-projects\nodejs-docker-app/src:/app/src:ro -d -p 4000:4000 node-docker-dev`: Create a container that listen to changes at `src` folder and make hot reload at the container to reload any change happened at `src` folder.**



- **`docker run --name containerName -v fullPathOfTheMainFile Or %cd%:/folderNameInDockerfile -d -p 4000:4000 node-docker-dev`: This is an instance of create a hot reload container, for example ➡ `docker run --name express-container -v d:\programming\projects\local-projects\nodejs-docker-app:/app:ro -d -p 4000:4000 node-docker-dev.`, And remember to set `start:dev` script in `package.json` to ➡ `nodemon --legacy-watch src/index.ts` and we put this option `:ro` to make the container `read-only`**



- **`docker run --name dockerName -v  fullPathOfTheMainFile Or %cd%:/folderNameInDockerfile -v specifyFolderOrFileIdidnotWannaChangeAnythingAtIt(/app/node_modules) -d -p 4000:4000 node-docker-dev`: Creates a new container with anonymous volume, That's mean it'll keep the `docker container` without any change, And if there's changes at local machine won't influnce at the `docker container`.**



- **`docker run -d `: Runs a container in detached mode (in the background).**



- **`docker run -it `: Runs a container interactively with a terminal.**



- **`docker run --name  `: Runs a container with a specified name.**



- **`docker ps`: Lists all running containers.**



- **`docker ps -a`: Lists all containers, including stopped ones.**



- **`docker stop `: Stops a running container.**



- **`docker start `: Starts a stopped container.**



- **`docker restart `: Restarts a container.**



- **`docker kill `: Kills a running container.**



- **`docker rm `: Removes a container.**



- **`docker rm  -f`: Forces Remove a container .**



- **`docker exec -it  `: Runs a command in a running container (interactive).**



- **`docker logs `: Shows the logs from a container.**



- **`docker inspect `: Displays detailed information about a container or image.**



- **`docker commit  `: Creates a new image from a container's changes.**



- **`docker attach `: Attaches to a running container's console.**



- **`docker volume create `: Creates a new volume.**



- **`docker volume ls`: Lists all volumes.**



- **`docker volume rm `: Removes a volume.**



- **`docker volume inspect `: Displays detailed information about a volume.**



- **`docker network create `: Creates a new network.**



- **`docker network ls`: Lists all Docker networks.**



- **`docker network rm `: Removes a Docker network.**



- **`docker network inspect `: Displays detailed information about a network.**



- **`docker network connect  `: Connects a container to a network.**



- **`docker network disconnect  `: Disconnects a container from a network.**



- **`docker-compose up`: Builds, (re)creates, starts, and attaches to containers for a service.**



- **`docker-compose up -d`: Starts containers in detached mode.**



- **`docker-compose down`: Stops and removes containers, networks, images, and volumes.**



- **`docker-compose ps`: Lists containers in the current Docker Compose project.**



- **`docker-compose logs`: Shows logs from Docker Compose services.**



- **`docker-compose build`: Builds or rebuilds services.**



- **`docker-compose stop`: Stops running containers without removing them.**



- **`docker-compose start`: Starts existing containers.**



- **`docker-compose restart`: Restarts all the services defined in the docker-compose.yml.**



- **`docker login`: Logs in to a Docker registry.**



- **`docker logout`: Logs out from a Docker registry.**



- **`docker push `: Uploads a local image to a Docker registry.**



- **`docker pull `: Downloads an image from a Docker registry.**



- **`docker system df`: Shows disk usage by Docker.**



- **`docker system prune`: Cleans up unused Docker data (containers, images, networks, etc.).**



- **`docker system info`: Displays system-wide information about Docker.**



- **`docker stats`: Shows a live stream of resource usage statistics for containers.**



- **`docker save -o  `: Saves an image to a tar archive.**



- **`docker load -i `: Loads an image from a tar archive.**



### _Dockerfile Commands_



- **First to build an image of Dockerfile ➡ `docker build .` it works in case if i'm in the folder which include the Dokerfile.**



- **To name the Docker image to separate the iamges with names ➡ `docker build -t imageName .` .**



- **To see list of all images in your device ➡ `docker image ls`.**



- **To run the a container and name it, from `Docker Image` that we have ➡ `docker run --name containerName -p  forward port:internal port  imageName`.**



- **To see list of all running containers in your device ➡ `docker ps`.**



- **To stop container ➡ `docker stop containerName`.**



- **To remove a container ➡ `docker rm containerName -f`.**



- **`FROM `: Specifies the base image for the Docker image.**



- **`LABEL =`: Adds metadata to the image in the form of key-value pairs.**



- **`ENV =`: Sets environment variables within the image.**



- **`RUN `: Executes a command during the image build process, typically used for installing packages.**



- **`COPY  `: Copies files or directories from the host machine into the image.**



- **`ADD  `: Similar to `COPY`, but with additional features like auto-extracting compressed files.**



- **`WORKDIR `: Sets the working directory for subsequent instructions in the Dockerfile.**



- **`CMD ["executable", "param1", "param2"]`: Specifies the default command to run when a container is started.**



- **`ENTRYPOINT ["executable", "param1", "param2"]`: Configures a container to run as an executable.**



- **`EXPOSE `: Informs Docker that the container listens on the specified network ports at runtime.**



- **`VOLUME ["/data"]`: Creates a mount point with the specified path and marks it as holding externally mounted volumes or bind mounts.**



- **`USER `: Sets the user to use when running the image’s CMD or ENTRYPOINT.**



- **`ARG [=]`: Defines a variable that users can pass at build-time to the builder with the docker build command.**



- **`ONBUILD `: Adds a trigger instruction to be executed when the image is used as a base for another build.**



- **`HEALTHCHECK  CMD `: Defines a command that runs to check that the container is healthy.**



- **`SHELL ["executable", "param1", "param2"]`: Allows the default shell used for the shell form of commands to be overridden.**



---



- ## _Docker Compose_



- **The first step to use `Docker-Compose` is create file called `docker-compose.yml`.**



- **If you wanna run docker in different enviroments, You should run docker-compose file for each enviroments.**



- **When i had different `docker-compose` files and i wanna run specific file : `docker-compose -f dockerComposeFileName up`.**



- **In case if we had many different `docker-compose` files like `dev | pord | stag`, we create a file called `docker-compose.yml` and write all common structure between files i it, then in those other files we write only what related with each of those specific files.**



- **Ensure you don't forget to add this line `docker-compose*` in `.dockerignore` to avoid all `docker-compose` files to be included in the containers that we gonna create.**



- **When i had different `docker-compose` files and `mainComposeFile` like `docker-compose.yml` and i wanna run specific file and the main docker-compose : `docker-compose -f docker-compose.yml -f docker-compose.dev.yml up` and if you want it build again the command will be `docker-compose -f docker-compose.yml -f docker-compose.dev.yml up --build -d`.**



- **After adding any new image you have to build the new image before create any container.**



### _Common Docker Compose Commands_



- **`docker compose up`: Build, (re)create, start, and attach to containers for a service.**

- **`docker compose down`: Stop and remove containers, networks, images, and volumes.**

- **`docker compose build`: Build or rebuild services.**

- **`docker compose stop`: Stop services.**

- **`docker compose start`: Start services.**

- **`docker compose restart`: Restart services.**

- **`docker compose logs`: View output from containers.**

- **`docker compose ps`: List containers.**

- **`docker compose exec  `: Execute a command in a running container.**



---



## _Difference Between Images & Containers_



### _Docker Images_



- **`Definition`: A Docker image is a lightweight, standalone, and immutable file that contains everything needed to run a piece of software, including the code, runtime, libraries, environment variables, and configuration files..**

- **`Read-Only`: Docker images are read-only templates used to create Docker containers. They do not change once they are created..**

- **`Layered Structure`: Docker images are made up of layers. Each layer represents a set of file changes (like an addition or modification), and layers are stacked on top of each other to form a single image. This layering allows Docker to reuse layers between images, which makes them more efficient in terms of storage and speed.**

- **`Storage`: Images are stored in the Docker registry (such as Docker Hub) or locally on your machine. They can be shared and distributed, making them highly portable.**

- **`Creation`: Docker images are typically built from a Dockerfile, which is a script that specifies the instructions needed to create the image.**



### _Docker Containers_



- **`Definition`: A Docker container is a running instance of a Docker image. It is an isolated, lightweight, and executable software package that includes everything needed to run an application.**



- **`Mutable`: Unlike images, containers are mutable. When you run a container, it is created from an image and can be modified. Any changes made inside a container, such as modifying files or installing software, are specific to that container instance.**



- **`Runtime`: Containers provide a runtime environment where the application specified in the Docker image can be executed. They have their own isolated filesystem, network interfaces, and processes.**



- **`Lifecycle`: Containers have a lifecycle—they can be started, stopped, restarted, and removed. Once a container is stopped, it can be restarted or removed without affecting the original image.**



- **`Ephemeral`: Containers are often designed to be ephemeral, meaning they are created, used, and then discarded. Changes made to a container are not reflected back in the image unless explicitly committed to create a new image.**



### _Key Differences_



#### _Immutability vs. Mutability:_



- **Images are immutable and cannot be changed once created.**

- **Containers are mutable, and you can make changes to a running container.**



#### _Role:_



- **Images serve as the blueprint or template for creating containers.**

- **Containers are the actual running instances of images.**



#### _Storage:_



- **Images are stored as layers in the Docker registry or locally and can be reused.**

- **Containers use the image as a base and have their own writable layer where changes are made.**



#### _Creation_:



- **Images are built from Dockerfiles or created by committing changes from a container.**

- **Containers are created from images and run the software specified in the image.**



#### _Persistence_:



- **Images are persistent and can be stored and distributed.**

- **Containers are ephemeral by default, and changes made to them do not persist unless committed to an image or saved in volumes.**