Important docker commands and notes.

Docker_Commands.md

Docker

Docker is a tool that help us to work with the containers. We can pull the images from it's public docker hub repo and run the images in our machine to work with softwares like nodejs, mongodb, linux which otherwise needs to be installed on our Operating System manually.

Containers are the isolated environments in your system that runs on the top of your systems infrastructure but are in isolation. Containers itself doesn't contain the full operating system but rather it contains some binaries. Docker sits in between our machine Operating system and the Container to manage how we use the our computer resources.

to share the container we create the Images of our container which can be replicted on other machine. Images can also be created from Dockerfile. Image contain set of instruction about how to create the container. Think this as image is an Class and Container is it's Object/Instance.

Docker follows Client Server architecture under the hood. So there are three things :

• docker cli <- This is our client
• docker daemon <- This is the server
• REST API <- This sets communication between cli commands and the daemon.

Docker Commands

• docker --version : To know the version of the docker
• docker ps : To list the running containers
  • docker ps -a : To list all the containers running/stopped.
• docker run ubuntu:latest : This will start running our ubuntu container, replace latest with version number if required, if the iamge is not present it will look in the container registry and then download it.
  • docker run -it ubuntu:latest /bin/bash : start container while opening an interactive terminal session inside the container.
  • docker run -d ubuntu : Run the container in detached mode.
  • docker run -dit --name my-ubuntu ubuntu:latest : If you want the container to stay alive silently in the background so you can connect to it later, combine detached (-d) and interactive flags
  • docker exec -it my-ubuntu bash : if you started the container with previous command then you can enter into it with this command. container when running we use the exec command.
• docker pull node:<version> : To pull the image from remote registry
• docker stop containerId : stop the running container.
• docker container prune : delete all the stopped containers.

Docker pull consist of three command which runs automatically

We can run them one by one too.

• docker pull node:22-alpine : Ran the container from local image, otherwise pull from the docker hub.
• docker create node:22-alpine : Creates a new writeable container layer over the specified image and prepares its execution configuration.
• docker start <container> : Boots up the newly created container, assigns it a process ID, and executes its main startup application or custom script we can attach the flags to these commands to mimic behaviour of docker run

📂 Real-Time Code Syncing with Docker Bind Mounts

This guide covers how to link a local folder on your host machine to a running Docker container. This allows you to write code in your local text editor (like VS Code) and have it execute instantly inside a containerized environment without losing data.

---

🚀 Part 1: Initializing the Local Environment

1. Create a Project Folder

Open your local terminal (Git Bash, PowerShell, or CMD) and create your workspace:

mkdir docker-node-project
cd docker-node-project

2. The Mounting Command (Terminal Shortcuts)

To link your folder, you must spin up the container using a Bind Mount (-v) and a Working Directory (-w) flag. Choose the command that matches your terminal:

• Git Bash (Windows): (Requires an extra forward slash / to stop path scrambling)

  docker run -dit --name local-node-env -p 8080:3000 -v /"\$(pwd)":/app -w /app node:alpine

• PowerShell (Windows):

  docker run -dit --name local-node-env -p 8080:3000 -v \${PWD}:/app -w /app node:alpine

• Command Prompt / CMD (Windows):

  docker run -dit --name local-node-env -p 8080:3000 -v %cd%:/app -w /app node:alpine

💡 Alternative: Using Hardcoded Absolute Paths

Instead of relying on terminal variables like $(pwd) or %cd%, you can explicitly type out the exact absolute path to your folder. This works reliably across different terminal windows:

docker run -dit \
  --name local-node-env \
  -p 8080:3000 \
  -v "C:\Users\Lenovo\Desktop\docker-node-project":/app \
  -w /app \
  node:alpine

(Ensure you wrap the Windows path in quotes if your folder names contain spaces!)

---

🏗️ Part 2: Terminal Discipline (Where to Run Commands)

When using bind mounts, your local computer folder and the container folder are a single, synced space. However, your laptop and the container have completely different operating systems and engines.

You must be disciplined about where you type your commands:

Command	Where to Run It	Why?	What Happens If You Do It Wrong?
Code Editing (Ctrl + S, writing JS)	Local Laptop (VS Code)	You get to use your native desktop UI, extensions, and themes smoothly.	Editing files inside the container terminal forces you to use raw terminal tools like vi.
npm install	Inside Container (docker exec)	The container is running Alpine Linux. It compiles packages specifically for Linux architectures.	If run on Windows, it creates Windows binaries. The Linux container will crash with Invalid Win32 application errors.
npm start	Inside Container (docker exec)	The application process must run inside the isolated Docker network to use the -p port mapping.	If run on your laptop, the app runs natively on Windows, completely bypassing Docker and its configuration.

---

📝 Part 3: Writing Code and Syncing Files

1. Create files locally

Open the docker-node-project folder in VS Code on your laptop and create these two files:

package.json

{
  "name": "docker-mount-test",
  "version": "1.0.0",
  "main": "server.js",
  "scripts": {
    "start": "nodemon -L server.js"
  },
  "dependencies": {
    "express": "^4.19.2"
  },
  "devDependencies": {
    "nodemon": "^3.1.0"
  }
}

server.js

const express = require('express');
const app = express();

app.get('/', (req, res) => {
    res.send('Live syncing is working beautifully!');
});

app.listen(3000, () => {
    console.log('Containerized app listening on port 3000');
});

2. Execute within the Container Environment

Following the discipline rules above, open an execution session into your container to install and run the stack:

# 1. Enter the container terminal
docker exec -it local-node-env sh

# 2. Install packages inside Linux environment
npm install

# 3. Start the application
npm start

(Check your laptop folder—the node_modules folder generated inside the container has successfully synced backward to your local Windows computer filesystem!)

---

🛠️ Part 4: Overcoming the Windows File-System Trap

The Problem: Nodemon doesn't reload on file save

When you save a file in Windows, the underlying Linux filesystem inside the container does not always receive the file-change notification event across the Docker Desktop file-sharing bridge. Standard nodemon will sit idle and miss your code changes.

The Fix: Legacy Watch (Polling)

You must force Nodemon to actively scan and poll the filesystem for changes by adding the -L (or --legacy-watch) flag.

Ensure your package.json start script uses the flag:

"start": "nodemon -L server.js"

Alternatively, trigger it manually inside the container shell using:

npx nodemon -L server.js

With polling enabled, saving your server.js in VS Code will now instantly trigger a server restart inside the container. You only need to manually refresh your browser at http://localhost:8080 to see updates.