<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Pawarmanas on Medium]]></title>
        <description><![CDATA[Stories by Pawarmanas on Medium]]></description>
        <link>https://medium.com/@pawarmanas47?source=rss-0f408ac2b31a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*k_Pk7WtjLYrSQ6om</url>
            <title>Stories by Pawarmanas on Medium</title>
            <link>https://medium.com/@pawarmanas47?source=rss-0f408ac2b31a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 15:16:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pawarmanas47/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Why Does Docker Need Instructions to Build an Environment?]]></title>
            <link>https://medium.com/@pawarmanas47/why-does-docker-need-instructions-to-build-an-environment-3cd227a60d01?source=rss-0f408ac2b31a------2</link>
            <guid isPermaLink="false">https://medium.com/p/3cd227a60d01</guid>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[systems-thinking]]></category>
            <dc:creator><![CDATA[Pawarmanas]]></dc:creator>
            <pubDate>Sat, 27 Jun 2026 06:06:36 GMT</pubDate>
            <atom:updated>2026-06-27T06:06:36.057Z</atom:updated>
            <content:encoded><![CDATA[<p>Learn Docker With Me — Part 4</p><h4>A Dockerfile Is More Than a Build Script — It’s a Reproducibility Contract</h4><p>In the last article, we successfully ran our first few containers. We spun up <strong>Nginx</strong>, <strong>PostgreSQL</strong>, and <strong>Redis</strong> with a single command.</p><pre>docker run nginx <br>docker run postgres <br>docker run redis</pre><p>It felt almost magical. But then I realized something. All of these images were created by <strong>someone else</strong>. We were simply downloading them and running them. That raised an interesting question.</p><blockquote>What if I want to containerize my own application?</blockquote><p>Docker doesn’t know anything about my project. It doesn’t know:</p><ul><li>Which programming language I’m using.</li><li>Which version of Node.js I need.</li><li>Which dependencies to install.</li><li>Which file starts my application.</li><li>Which port my application listens on.</li></ul><p>Someone has to tell Docker all of this. That’s exactly why <strong><em>Dockerfiles</em></strong> exist.</p><h3>Docker Doesn’t Read Minds</h3><p>Imagine you ask someone to bake a cake. You don’t just say : <em>“Bake me a chocolate cake.”</em></p><p>Instead, you give them a recipe. The recipe explains:</p><ul><li><em>which ingredients to use,</em></li><li><em>what order to follow,</em></li><li><em>how long to bake,</em></li><li><em>and how the final cake should look.</em></li></ul><p>Anyone who follows the same recipe ends up with almost the same cake. Docker works exactly the same way. Instead of giving Docker an application… we give Docker a <strong>recipe</strong> for building the environment that application needs. That recipe is called a <strong>DockerFile</strong>.</p><h3>DockerFile</h3><pre>Base Image <br>    ↓ <br>Copy Files<br>    ↓ <br>Install Dependencies<br>    ↓ <br>Run Application</pre><p>The beauty of this approach is consistency. Every developer. Every machine. Every server. Follows the exact same recipe. No setup documents. No missing dependencies. No guessing.</p><h3>Meet the Dockerfile</h3><p>Here’s the example of a complete Dockerfile we’ll build step by step.</p><pre>FROM node:20-alpine <br><br>WORKDIR /app <br><br>COPY package*.json ./ <br><br>RUN npm install <br><br>COPY . . <br><br>EXPOSE 3000 <br><br>CMD [&quot;node&quot;, &quot;server.js&quot;]</pre><p>At first glance…</p><p>it probably looks like a random list of commands. That’s exactly what I thought when I saw my first Dockerfile. But once you understand <strong>why each instruction exists</strong>, the entire file becomes surprisingly easy to read.</p><p>Let’s build it one instruction at a time.</p><h4>Step 1 — Choosing the Foundation (FROM):</h4><p>Every building starts with a foundation. Every Docker image does too.</p><pre>FROM node:20-alpine</pre><p>This line tells Docker: <strong><em>“Start with an image that already has Node.js 20 installed.”</em></strong></p><p>Instead of creating everything from scratch, Docker builds on top of an existing image. Think of it like buying a fully furnished apartment instead of building a house brick by brick.</p><p>the first instruction always answers one question:</p><blockquote><strong>What environment should Docker start with?</strong></blockquote><p>You may have noticed the word: <em>alpine . </em>What is Alpine? Alpine Linux is a lightweight Linux distribution. They are just a smaller version of the actual image , efficient for managing the images.</p><p>Smaller images mean:</p><ul><li>Faster downloads</li><li>Faster deployments</li><li>Less storage usage</li></ul><p>That’s why Alpine images are extremely popular in production environments.</p><h4>Step 2 — Choosing Where Our Application Lives (WORKDIR)</h4><p>Next we write : “<em>WORKDIR /app”</em></p><p>This instruction confused me initially because it didn’t seem to do much. But think about your normal terminal. Whenever you start working on a project, the first thing you usually do is: <strong><em>“cd project-folder”</em></strong></p><p>Only after entering the folder do you begin running commands. WORKDIR does exactly that.</p><p>It tells Docker: “From this point onward, treat /app as the current working directory.&quot; If the directory doesn’t already exist, Docker creates it automatically. Hence very instruction after this runs inside /app.</p><h3>Step 3 — Bringing the Project Inside (COPY)</h3><p>Our container currently has Node.js.</p><p>It has npm. It has Linux. But… it doesn’t have <strong>our application</strong>. That’s where COPY comes in.</p><pre>COPY package*.json ./</pre><p>This instruction copies our package files into the current working directory inside the container. Notice something interesting. We’re <strong>not</strong> copying the whole project yet. Only these files. Why??</p><p>Because Docker is smarter than it first appears. Suppose your project looks like this.</p><pre>product-api/-<br><br>package.json <br>package-lock.json <br>server.js <br>routes/ <br>controllers/ <br>models/</pre><p>Now imagine you change only one line inside server.js. Did your dependencies change? NO.<br>Only your application code changed.<br>Docker takes advantage of this. Instead of reinstalling every package on every build, it checks whether the package files changed.<br>If they didn’t… Docker simply reuses the previous installation.</p><p>That process is called <strong>Layer Caching</strong>, and it can reduce build times from minutes to seconds.<br>We’ll see exactly how that works later in this article.</p><h4>Step 4 — Installing Dependencies (RUN)</h4><p>Now that Docker has the package files, it finally knows which dependencies our project requires.<br>So we write:</p><pre>RUN npm install</pre><p>This is one of the most misunderstood instructions in a Dockerfile. Many beginners — including me also — assumed that this command runs every time the container starts.<br>It doesn’t.</p><p>It runs <strong>only while Docker is building the image</strong>. Think of it like preparing ingredients before opening a restaurant.<br>When Docker reaches this instruction, it installs all the packages listed in package.json and stores them inside the image.<br>From that point onward, every container created from this image already has those dependencies available.</p><p>REMEMBER : <br>RUN belongs to <strong>building</strong> the image.<br>CMD belongs to <strong>running</strong> the container.</p><p>Wait what is this CMD again ? Lets check that out together !!</p><h4>Step 5 — Copying the Rest of the Application (COPY . .)</h4><p>At this point, our image already contains:</p><ul><li>Node.js</li><li>npm</li><li>Our project dependencies</li></ul><p>But something is still missing. The actual application. That’s why the next instruction is:<br>COPY . .</p><blockquote>This simply tells Docker: <br>“Copy everything else from my project into the current working directory inside the image.”</blockquote><p>After this step, our image finally contains our complete application. Now Docker has everything it needs to run our application.</p><h4>Step 6 — Documenting the Application Port (EXPOSE)</h4><p>The next instruction is :<br>EXPOSE 3000 <br>Think of EXPOSE as putting a label on a package. It tells Docker:</p><blockquote>“This application is expected to listen on port <strong>3000</strong>.”</blockquote><p>That’s all. It doesn’t actually publish the port. If you want to access the application from your computer, you still need to map the port when running the container.<br>docker run -p 3000:3000 container_name</p><p>Think of it like this.</p><pre>Dockerfile<br><br>EXPOSE 3000 <br>      │ <br>      ▼ <br>&quot;I&#39;m listening on port 3000.&quot; <br><br><br>docker run -p 3000:3000 <br>        │<br>        ▼ <br>&quot;Allow my computer to access it.&quot;</pre><p>One instruction documents the port. The other actually makes it reachable!</p><h4>Step 7 — Starting the Application (CMD)</h4><p>So far we’ve built an environment. But Docker still doesn’t know one thing. What should it execute when the container starts? That’s exactly what CMD answers.</p><pre>CMD [&quot;node&quot;, &quot;server.js&quot;]</pre><p>When someone runs:</p><pre>docker run container_name</pre><p>Docker looks for the default startup command. It finds:</p><pre>CMD [&quot;node&quot;, &quot;server.js&quot;]</pre><p>and executes it automatically. Without CMD, Docker would create the container… and then have nothing to do. The application would never start. Think of it this way.</p><pre>Container Starts<br>       │<br>       ▼ <br>Looks for CMD<br>       │<br>       ▼ <br>node/ server.js /etc...<br>       │ <br>       ▼<br>Application Running</pre><p>CMD is essentially the answer to the question:</p><blockquote>“What should happen when this container comes to life?”</blockquote><h3>Our Dockerfile Is Complete</h3><p>Now let’s look at the complete file again. This time, every instruction should make sense.</p><pre>FROM node:20-alpine <br>WORKDIR /app <br>COPY package*.json ./ <br>RUN npm install <br>COPY . . <br>EXPOSE 3000 <br>CMD [&quot;node&quot;, &quot;server.js&quot;]</pre><p>Reading it almost feels like reading a story.</p><p>1.Start with Node.js.</p><p>2.Create a working directory.</p><p>3.Copy dependency files.</p><p>4.Install dependencies.</p><p>5.Copy the application.</p><p>6.Document the application port.</p><p>7.Start the server.</p><p>That’s exactly how Docker reads it too.</p><h3>Building The Image</h3><p>Writing a Dockerfile doesn’t create an image.<br>Docker still needs to read the instructions and build one. That’s where docker build comes in.</p><pre>docker build -t container_name .</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/922/1*5XwbkKSurwyGIK6YssfNyw.png" /><figcaption>reference table</figcaption></figure><h3>Keeping Images Clean with .dockerignore</h3><p>One more thing. Not every file in your project belongs inside a Docker image. Imagine your project contains:</p><pre>product-api/<br> node_modules/<br> .git/<br> .env<br> README.md<br> src/<br> package.json<br> Dockerfile</pre><p>Do we really want all of these inside the image?<br>Definitely not.<br>For example:</p><ul><li>.git is only useful for version control.</li><li>node_modules will already be installed inside the container.</li><li>.env may contain sensitive information.</li><li>README.md isn&#39;t needed to run the application.</li></ul><p>That’s why we create a .dockerignore file.</p><blockquote>node_modules<br> .git<br> .env<br> README.md</blockquote><p>Docker simply ignores these files while building the image.<br>Smaller images.<br>Faster builds.<br>Cleaner deployments.</p><h3>Running Our Image</h3><p>Once the image has been built, running it feels familiar.</p><pre>docker run -d -p 3000:3000 --name product-api product-api</pre><p>Let’s decode it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/688/1*DdKSHqXcBcFcSSnUa7qx8A.png" /><figcaption>reference table</figcaption></figure><p>If everything goes well, your application is now running inside its own container.<br>Exactly the environment described by the Dockerfile.</p><h3>What I Learned</h3><ul><li>A Dockerfile is a recipe for building an image.</li><li>FROM chooses the starting environment.</li><li>WORKDIR sets where future commands execute.</li><li>COPY moves files into the image.</li><li>RUN executes commands during image creation.</li><li>EXPOSE documents which port the application listens on.</li><li>CMD defines what runs when the container starts.</li><li>Docker caches layers to make future builds much faster.</li><li>.dockerignore keeps images smaller and cleaner.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YIgkHqvFrC8m0Ey_ouAUKg.png" /><figcaption>Summarized Image</figcaption></figure><h3>Up Next</h3><p>So far we’ve built a simple image.<br>But our Product API still isn’t ready for production.</p><p>In the next article, we’ll package a complete Express-based Product API into a production-ready Docker image and start building the first real service of the application.</p><p>Because writing a Dockerfile is only the beginning.<br>The real journey starts when we begin containerizing our own applications………………………………..</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3cd227a60d01" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Actually Happens When You Run Your First Container?]]></title>
            <link>https://medium.com/@pawarmanas47/what-actually-happens-when-you-run-your-first-container-34a1549f507a?source=rss-0f408ac2b31a------2</link>
            <guid isPermaLink="false">https://medium.com/p/34a1549f507a</guid>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Pawarmanas]]></dc:creator>
            <pubDate>Fri, 26 Jun 2026 06:19:54 GMT</pubDate>
            <atom:updated>2026-06-26T08:54:03.416Z</atom:updated>
            <content:encoded><![CDATA[<p>Learn Docker With Me — Part 3</p><p>In the previous article, we installed Docker and verified that everything was working. We even ran: “<strong><em>docker run hello-world” .</em></strong></p><p>It worked. But I realized something. I had successfully run a container but ……. without actually understanding how?</p><p>So before we build our own applications, let’s answer a simple question: <strong>What really happens when you run your first container?</strong></p><h3>Running Our First Real Container:</h3><p>Instead of the hello-world image, let&#39;s start something more practical. We’ll run <strong>Nginx</strong>, one of the most popular web servers in the world.</p><pre>docker run nginx</pre><p>The <strong>very first</strong> time you execute this command, Docker responds with something like:</p><pre>Unable to find image &#39;nginx:latest&#39; locally <br>latest: Pulling from library/nginx <br>...</pre><p>A few moments later… the container starts running. Your terminal now appears “stuck” but it isn’t actually . Your terminal is attached to the running container. Just press <strong>Ctrl + C</strong> to stop it.</p><h4>What Just Happened?</h4><p>Although we executed a single command, Docker actually performed several steps behind the scenes.</p><p>Docker didn’t simply “run Nginx.” It first downloaded the required image, created a brand-new container from that image, started it, and finally connected your terminal to the running process.</p><p>Pheww…. That’s a lot of work from a single command.</p><h3>Running Containers in the Background</h3><p>Keeping the terminal occupied isn’t very practical. Most services are expected to run quietly in the background. And hence ,Docker provides the <strong>Detached Mode</strong> for exactly this purpose.</p><pre>docker run -d nginx</pre><p>The output looks something like: “<strong><em>a3f5c7d8e9b123456…” </em></strong>a hashed string. This long string is the <strong>Container ID</strong>. The container continues running in background even though your terminal is free again.</p><h3>Viewing Running Containers</h3><p>To see what’s currently running you can just run :</p><pre>docker ps</pre><p>Example output:</p><pre>CONTAINER ID     IMAGE      STATUS         PORTS         NAMES<br>a3f5c7d8e9b1     nginx      Up 30 sec      80/tcp      quirky_newton</pre><p>Each column tells a story.</p><ul><li><strong>CONTAINER ID</strong> — Unique identifier (use first few characters)</li><li><strong>IMAGE</strong> — What image it’s running</li><li><strong>STATUS</strong> — Running, stopped, etc.</li><li><strong>PORTS</strong> — Network ports (not accessible yet!)</li><li><strong>NAMES</strong> — Auto-generated name (or custom)</li></ul><h3>Why Can’t I Open the Website?</h3><p>At this point Nginx is running. But opening: <em>“http://localhost” </em>doesn’t work. Why? Because containers are isolated. Their internal ports are <strong>not automatically exposed</strong> to your machine. Hence we need something called <strong><em>Port Mapping</em></strong><em>.</em></p><h4>Port Mapping:</h4><p>Stop the old container.</p><pre>docker stop &lt;container-id&gt;</pre><p>Now run:</p><pre>docker run -d -p 8080:80 nginx</pre><p>The syntax means:</p><pre>Your Computer       Container<br><br>localhost:8080 ─────► Port 80</pre><p>Now visit: <a href="http://localhost:8080/">http://localhost:8080</a> ,You’ll finally see the familiar <strong>Nginx Welcome Page</strong>. Congratulations 🎉 🎉</p><p>You just served your first website from inside a container.</p><h3>Running a Real Database</h3><p>Let’s see how you deal with Database in docker world !!</p><p>We’ll use PostgreSQL.</p><pre>docker run -d \<br>  --name shopflow-db \<br>  -e POSTGRES_USER=shopflow \<br>  -e POSTGRES_PASSWORD=secretpass \<br>  -e POSTGRES_DB=products \<br>  -p 5432:5432 \<br>   postgres:15</pre><p>At first glance this command looks intimidating. But each option has a specific purpose.</p><pre>Flag                                              Purpose<br><br>-d                                             Run in background<br><br>--name                                    Give the container a readable name<br><br>-e                                            Set environment variables<br><br>-p                                               Map ports<br><br>postgres:15                                      Image and version<br></pre><p>Once running: “<strong><em>docker ps” </em></strong>it<strong><em> </em></strong>should list your database container.</p><h4>Talking to the Database:-</h4><p>Running a database is one thing. Using it is another. Docker lets us execute commands inside an already-running container.</p><pre>docker exec -it shopflow-db psql -U shopflow -d products</pre><p>Now , you’re now inside PostgreSQL. Try creating a table. Insert some data. Then verify it as well.</p><pre>CREATE TABLE products ( <br>id SERIAL PRIMARY KEY, <br>name VARCHAR(100),<br>price DECIMAL(10,2)<br>);<br><br>INSERT INTO products(name,price)<br>VALUES(&#39;Wireless Headphones&#39;,79.99);<br><br>SELECT * FROM products;</pre><p>Exit with: \q</p><h3>Running Redis</h3><p>Multiple platforms also use Redis. Instead of permanent storage, Redis keeps temporary data such as:</p><ul><li>Shopping carts</li><li>User sessions</li><li>Frequently accessed data</li><li>Top Level data access</li></ul><p>Starting Redis is just as simple:</p><pre>docker run -d \<br>--name shopflow-cache \<br>-p 6379:6379 \<br>redis:7-alpine</pre><p>Notice the image name. redis:7-alpine The <strong>Alpine</strong> tag provides a much smaller image, making downloads faster and containers lighter</p><h3>Naming Containers Makes Life Easier</h3><p>Docker automatically generates names like: “<strong><em>quirky_newton” </em></strong>They’re fun. But not very practical. Instead:</p><pre>docker run -d --name product-api nginx</pre><p>Now every command becomes easier by mentioning the name directly. Readable names make container management significantly simpler.</p><h3>Few More Essential Commands You’ll Use Every Day</h3><p>Rather than memorizing dozens of commands, these are the ones you’ll use most often.</p><pre>docker ps : List running containers.<br>docker ps -a : List every container.<br>docker logs &lt;container&gt; : View container logs.<br>docker stop &lt;container&gt; : Stop a running container.<br>docker start &lt;container&gt; : Starts the container.<br>docker exec -it &lt;container&gt; bash : Open a shell inside a running container.</pre><p>These commands form the foundation of everyday Docker development.</p><h3>Cleaning Up</h3><p>After experimenting, it’s good practice to clean your environment.</p><pre>docker stop $(docker ps -q) : Stop every running container<br><br>docker container prune : remove unused containers.<br><br>docker image prune  :  remove unused images.</pre><h3>What We Learned</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x1Hm0_NsUpOS5I3Gq3rNfg.png" /></figure><p>Before writing this article, I thought a container was simply “an isolated application.” Now I see it differently. A container is created from an image. It has its own filesystem. Its own processes. Its own networking. Its own lifecycle.</p><p>Running a container isn’t just starting a program. It’s creating an entirely isolated environment for that specific program to live in.</p><h3>Up Next:</h3><p>So far we’ve been using images built by other people. But sooner or later we’ll need to package <strong>our own application</strong>. That means creating our very first <strong>DockerFile</strong>. And that’s exactly where we’ll go next.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=34a1549f507a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Installing Docker Is Easy. Understanding Why You're Installing It Is Harder.]]></title>
            <link>https://medium.com/@pawarmanas47/installing-docker-is-easy-understanding-why-youre-installing-it-is-harder-6fb54791e5e6?source=rss-0f408ac2b31a------2</link>
            <guid isPermaLink="false">https://medium.com/p/6fb54791e5e6</guid>
            <category><![CDATA[system]]></category>
            <category><![CDATA[learning]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[virtualization]]></category>
            <dc:creator><![CDATA[Pawarmanas]]></dc:creator>
            <pubDate>Tue, 23 Jun 2026 03:57:15 GMT</pubDate>
            <atom:updated>2026-06-23T03:57:15.784Z</atom:updated>
            <content:encoded><![CDATA[<p>Learn Docker With Me — Part 2</p><p>In the previous article, we explored the problem that made Docker necessary. Developers weren’t struggling to write software.</p><p>But rather to run the same software consistently across different environments. And so <strong><em>the Containers became the solution.</em></strong></p><p>But before we run our first container, there’s a question worth asking:</p><blockquote><strong>What exactly is Docker?</strong></blockquote><p>Most tutorials jump directly into installation commands.</p><p>A few minutes later Docker is running. A few hours later containers are running.</p><p>Yet many developers still don’t know what they actually installed. So before we start containerizing applications, let’s take a quick look under the hood.</p><h3>Docker Is Not Just One Thing</h3><p>When I first started learning Docker, I imagined it as a single application.</p><p><strong>Install Docker &gt;Run containers &gt; Done ✅</strong></p><p>But Docker is actually a collection of various components working together. When you install Docker Desktop, you’re getting:</p><p><strong><em>✅ Docker Engine</em></strong></p><p><strong><em>✅ Docker CLI</em></strong></p><p><strong><em>✅ Docker Compose</em></strong></p><p><strong><em>✅ Docker Desktop UI</em></strong></p><p>And each component has a different job.</p><h3>1. Docker Engine</h3><p>This is the heart of Docker. The Engine is responsible for:</p><ul><li><strong><em>Pulling images</em></strong></li><li><strong><em>Creating containers</em></strong></li><li><strong><em>Managing networks</em></strong></li><li><strong><em>Managing volumes</em></strong></li><li><strong><em>Running workloads</em></strong></li></ul><p>Without Docker Engine, containers simply cannot exist. Think of it as the machinery that does all the heavy lifting.</p><h3>2. Docker CLI</h3><p>The CLI (Command Line Interface) is what we interact with every day.</p><p>Examples:</p><ol><li><strong><em>docker run</em></strong></li><li><strong><em>docker build</em></strong></li><li><strong><em>docker pull</em></strong></li><li><strong><em>docker compose up</em></strong></li></ol><p>Interestingly, the CLI doesn’t run containers itself. It simply sends https requests to Docker Engine.</p><h3>3.Docker Compose</h3><p>As applications grow, a single container is rarely enough. Our future application may contains services like :</p><ul><li><strong><em>Product Service</em></strong></li><li><strong><em>Cart Service</em></strong></li><li><strong><em>Payment Service</em></strong></li><li><strong><em>Database</em></strong></li></ul><p>And many more . Hence managing all of these manually would be painful. <strong>Docker Compose</strong> allows us to define an entire application stack and start everything with a single command.</p><pre>docker compose up</pre><p>We’ll use this extensively later in the series.</p><h3>Docker Desktop</h3><ul><li><strong><em>Installation management</em></strong></li><li><strong><em>Resource configuration</em></strong></li><li><strong><em>Container monitoring</em></strong></li><li><strong><em>Logs and diagnostics</em></strong></li></ul><p>You can use Docker entirely from the command line. The Desktop interface simply makes things easier.</p><h3>Installing Docker</h3><p>Fortunately, installation is the easiest part of the journey. Choose the method appropriate for your operating system.</p><h4>1.macOS</h4><ul><li>Download Docker Desktop</li><li>Open the .dmg file</li><li>Drag Docker into Applications</li><li>Launch Docker</li><li>Wait for the whale icon to stabilize</li></ul><p>Apple Silicon users (M1/M2/M3) should download the Apple Chip version.</p><h4>2.Windows</h4><ul><li>Download Docker Desktop</li><li>Run the installer</li><li>Enable WSL 2 when prompted</li><li>Restart the machine</li><li>Launch Docker Desktop</li></ul><p><strong><em>Requirements:</em></strong></p><ul><li>Windows 10 or 11</li><li>64-bit architecture</li><li>WSL 2 or Hyper-V enabled</li></ul><h4>3.Linux (Ubuntu/Debian)</h4><p>Install Docker Engine directly:</p><pre># Update packages<br>sudo apt-get update<br><br># Install prerequisites<br>sudo apt-get install ca-certificates curl gnupg<br><br># Add Docker repository and key<br>sudo install -m 0755 -d /etc/apt/keyrings<br><br>curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \<br>sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg<br><br>sudo chmod a+r /etc/apt/keyrings/docker.gpg<br><br># Add repository<br>echo \<br>&quot;deb [arch=$(dpkg --print-architecture) \<br>signed-by=/etc/apt/keyrings/docker.gpg] \<br>https://download.docker.com/linux/ubuntu \<br>$(. /etc/os-release &amp;&amp; echo &quot;$VERSION_CODENAME&quot;) stable&quot; | \<br>sudo tee /etc/apt/sources.list.d/docker.list &gt; /dev/null<br><br># Install Docker<br>sudo apt-get update<br><br>sudo apt-get install \<br>docker-ce \<br>docker-ce-cli \<br>containerd.io \<br>docker-buildx-plugin \<br>docker-compose-plugin<br><br># Add yourself to the Docker group:<br><br>sudo usermod -aG docker $USER</pre><p>Log out and log back in for the change to take effect.</p><h3>Is Docker Installed Correctly?</h3><p>Let’s verify. Run :</p><pre>docker --version</pre><p>You should see something similar to: “<em>Docker version 24.x.x”</em></p><p>The exact version isn’t important. If Docker responds successfully, we’re ready for the next step.</p><h3>The Famous Hello World Test</h3><p>Every Docker journey starts here.</p><pre>docker run hello-world</pre><p>The output will look something like:</p><p><em>“Unable to find image ‘hello-world: latest’ locally , latest: Pulling from library/hello-world …</em></p><p><em>Hello from Docker! “</em></p><p>This message shows that your installation appears to be working correctly. At first glance, it looks like a simple success message. But something much more interesting just happened.</p><p>What Docker did:</p><ul><li>Checked your machine for the image.</li><li>Couldn’t find it.</li><li>Downloaded the image from Docker Hub.</li><li>Created a container.</li><li>Executed it.</li><li>Displayed the output.</li></ul><p>All from a single command. We’ll break down every one of these steps in the next article.</p><h3>What Actually Happens When You Type a Docker Command?</h3><p>One concept that helped Docker make sense for me was understanding its architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/910/1*oXlZywZ8mSirDHi6AdyWJQ.png" /></figure><p>The flow looks like this:</p><pre>You Type Command<br>        │<br>        ▼<br>Docker CLI<br>        │<br>        ▼<br>Docker Daemon<br>        │<br>        ▼<br>Container Runs<br>        │<br>        ▼<br>Output Returns</pre><p>This architecture becomes extremely important once we begin building and managing multiple containers.</p><h3>A Quick Health Check</h3><p>Before moving on, verify these commands work:</p><pre>docker compose version<br>docker ps<br>docker ps -a<br>docker images</pre><p>You may see empty results. That’s completely normal. We haven’t started building anything yet.</p><h3>Common Problems</h3><h4>1.Cannot Connect to Docker Daemon</h4><p>Docker may not be running.</p><p>Check: 1) Docker Desktop is open 2) Whale icon is visible.</p><p>Linux users: <em>“sudo systemctl start docker”</em></p><h4>2.Permission Denied</h4><p>Linux users may need: <em>“sudo usermod -aG docker $USER” .</em></p><p>Then log out and log back in.</p><h4>3.Docker Feels Slow</h4><p>Docker runs inside a Linux VM on macOS and Windows. Increasing available RAM often improves performance significantly. We’ll explore optimization techniques later in the series.</p><h3>What I Learned</h3><p>Installing Docker turned out to be the easiest part of learning Docker. The more interesting discovery was realizing that Docker isn’t a single tool. It’s a system.</p><p><strong><em>. A CLI communicating with a daemon.</em></strong></p><p><strong><em>. A daemon managing images.</em></strong></p><p><strong><em>. Images becoming containers.</em></strong></p><p><strong><em>. Containers becoming applications.</em></strong></p><p>And soon, applications becoming entire systems. Understanding that architecture makes every future Docker command easier to reason about.</p><h3>Up Next</h3><p>We’ve installed Docker. We’ve verified it works. We’ve seen a container run. Now it’s time to answer a much bigger question:</p><blockquote><strong>What actually happens when a container starts?</strong></blockquote><p>Because the first time I ran a container, I realized it wasn’t just another process. And that’s where Docker started becoming truly interesting.</p><h3>VISUALS ALWAYS DO BETTER ✨</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OqIs0VeIV1r9mMwLiprFQA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6fb54791e5e6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[DOCKER EPI. 1]]></title>
            <link>https://medium.com/@pawarmanas47/docker-epi-1-cb493c5b6c3d?source=rss-0f408ac2b31a------2</link>
            <guid isPermaLink="false">https://medium.com/p/cb493c5b6c3d</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[deployment]]></category>
            <dc:creator><![CDATA[Pawarmanas]]></dc:creator>
            <pubDate>Mon, 22 Jun 2026 17:50:22 GMT</pubDate>
            <atom:updated>2026-06-22T17:50:22.399Z</atom:updated>
            <content:encoded><![CDATA[<p>Part 1 of the Learn Docker With Me series</p><p>A few months ago, if someone had asked me:</p><p><strong><em>“Why do we need Docker?”</em></strong></p><p>I probably would’ve answered:</p><p><strong><em>“Because that’s how modern applications are deployed.”</em></strong></p><p>Technically correct.</p><p>But not really.</p><p>The more I looked into Docker, the more I realized something interesting:</p><p>Docker wasn’t created because developers wanted containers.</p><p>Docker became popular because developers were tired of <strong><em>solving the same problem over and over again.</em></strong></p><p>A problem you’ve probably seen before.</p><h3>The Most Famous Sentence(s) in Software Engineering</h3><p>Imagine you’re building an e-commerce application.</p><p>“<strong>Everything works perfectly on your laptop</strong>”</p><ol><li>The APIs respond correctly.</li><li>The database connects.</li><li>The payment service works.</li><li>The product catalog loads instantly.</li></ol><p>Then you deploy it to production.and suddenly everything breaks.The Node.js version is different.</p><p>A dependency is missing.</p><p>A library that existed on your machine doesn’t exist on the server.</p><p>The database behaves differently……</p><p><strong>And</strong></p><p>then comes the sentence every developer has heard:</p><blockquote><strong><em>“But it works on my machine.”</em></strong></blockquote><p>For years, software teams fought this battle every day.Docker didn’t invent a new way to build applications.It solved the chaos surrounding where those applications ran.</p><h3>The Shipping Container Story</h3><p>To understand Docker, it’s better to leave software for a moment…….</p><p>Before shipping containers existed, transporting cargo was messy.</p><p>Every company packed goods differently.</p><p>Every port had different loading systems.</p><p>Every ship required special handling.</p><p>Moving cargo from one place to another was slow, expensive, and error-prone.</p><p>Then came the shipping container.</p><p>Everything fit into one standardized box.</p><p>It didn’t matter whether it traveled by ship, truck, or train.</p><p>The container stayed the same.</p><p>The transportation system adapted around it.</p><h3>Before Standardization</h3><pre>Boxes<br>Crates<br>Barrels<br>Packages<br>↓<br>Every shipment handled differently</pre><h3>After Standardization</h3><pre>┌──────────────────────┐<br>│   Shipping Container │<br>└──────────────────────┘<br>Works on:<br>✓ Ships<br>✓ Trucks<br>✓ Trains<br>✓ Ports</pre><p>Software had a very similar problem.</p><h3>Docker’s Big Idea</h3><p>Instead of shipping only your application:</p><pre>My Application</pre><p>Docker ships:</p><pre>Application<br>+ Dependencies<br>+ Runtime<br>+ Configuration<br>= Container</pre><p>Now the environment travels with the application.</p><p>The result?</p><p>The same container can run on:</p><ul><li><strong>Your laptop</strong></li><li><strong>Your teammate’s laptop</strong></li><li><strong>A testing server</strong></li><li><strong>A production server</strong></li><li><strong>A cloud platform</strong></li></ul><p>Without changing anything.</p><h3>A Real E-Commerce Example</h3><p>Let’s imagine we’re building <strong>ShopFlow</strong>, a small online store.</p><p>The system contains multiple services:</p><p>Product Service -&gt; Node.js 20 + ImageMagick</p><p>Cart Service -&gt; Python 3.11</p><p>Payment Service -&gt; Node.js 18</p><p>Database -&gt; PostgreSQL 15</p><p>At first glance this seems manageable.</p><p>Until a new developer joins the team.</p><h3>The Traditional Setup</h3><pre>brew install node@20<br>brew install node@18<br>brew install python@3.11<br>brew install imagemagick<br>brew install postgresql@15</pre><pre>pip install redis</pre><pre># Something breaks</pre><pre># Search StackOverflow</pre><pre># Repeat</pre><p>Hours disappear.</p><p>Versions conflict.</p><p>Dependencies differ.</p><p>Machines drift apart.</p><p>And eventually:</p><blockquote><em>“It works on my machine.”</em></blockquote><h3>The Containerized Setup</h3><pre>docker compose up</pre><p>That’s it.</p><p>Every service receives exactly the environment it expects.</p><p>Node 18 remains Node 18.</p><p>Node 20 remains Node 20.</p><p>Python stays isolated.</p><p>Nothing conflicts.</p><p>The machine becomes irrelevant.</p><h3>Containers vs Virtual Machines</h3><p>At this point, I had another question.</p><p>If isolation is the goal…</p><p>Why not just use <strong>Virtual Machines?</strong></p><p>The answer becomes clear when you compare them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/1*3pyAVv0c8zAXgLYnUPbe9A.png" /></figure><p>A useful analogy :</p><h3>1.Virtual Machines</h3><p>Think of VMs as houses.Every house has:</p><ul><li>Its own foundation</li><li>Its own plumbing</li><li>Its own electrical system</li></ul><p>Completely independent.But expensive.</p><h3>2.Containers</h3><p>Think of containers as apartments.</p><p>Everyone shares the building infrastructure.</p><p>But each apartment remains isolated.</p><p>Much more efficient.</p><p>This is why a server can comfortably run dozens of containers while struggling to host the same number of virtual machines.</p><h3>Docker Didn’t Invent Containers</h3><p>One thing surprised me while learning Docker.</p><p>Docker didn’t actually invent containers.</p><p>Linux already had technologies like:</p><ul><li>Namespaces</li><li>cgroups</li></ul><p>that provided process isolation long before Docker existed.</p><p>Docker’s innovation was different.</p><p>It made containers accessible.</p><p>Instead of spending days configuring low-level Linux features, developers could simply run:</p><pre>docker run postgres</pre><p>or</p><pre>docker run redis</pre><p>or</p><pre>docker run nginx</pre><p>and get a working environment in seconds.</p><p>That simplicity changed everything.</p><h3>Why Containers Matter for E-Commerce</h3><p>Now imagine our store goes live.</p><p>It’s Black Friday.</p><p>Traffic suddenly jumps 10×.</p><p>Not every service experiences the same load.</p><p>More people browse products.</p><p>More users add items to carts.</p><p>More payment requests arrive.</p><p>With containers, services can scale independently.</p><pre>Product Service  → Scale Up<br>Cart Service     → Scale Up<br>Payment Service  → Scale Up</pre><pre>Database remains unchanged</pre><p>Even better:</p><p>If the payment service has a bug,</p><p>you can redeploy only that service.</p><p>The product catalog continues running.</p><p>The cart service continues running.</p><p>Customers continue shopping.</p><p>The entire system doesn’t need to be restarted.</p><p>This is one of the reasons modern architectures are built around containers.</p><h3>What We’ll Build Throughout This Series</h3><p>By the end of this series, we’ll containerize a complete software system.</p><pre>┌───────────────────────────────────┐<br>│          Docker Network           │<br>│                                   │<br>│  Product API    Cart Service      │<br>│        │             │            │<br>│        └──────┬──────┘            │<br>│               │                   │<br>│       Payment Service             │<br>│               │                   │<br>│              DB                   │<br>└───────────────────────────────────┘</pre><p>Along the way we’ll learn how to:</p><ol><li>Build custom Docker images</li><li>Connect services together</li><li>Persist data across restarts.</li><li>Manage Configuration</li><li>Use Dokcer Compose</li><li>Deploy an entire stack with a single command.</li></ol><h3>What I Learned</h3><p>After exploring why containers exist, I realized something:</p><p>Docker was never really about containers.</p><p>It was about consistency.</p><p>Containers became the mechanism.</p><p>Consistency was the goal.</p><p>The real promise wasn’t :</p><blockquote><strong><em>“Run applications in containers.”</em></strong></blockquote><p>It was:</p><blockquote><strong><em>“Run the same application the same way everywhere.”</em></strong></blockquote><p>And that single idea changed how modern software are now built and deployed.</p><h3>RECAP through Visual</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/863/1*GUxfysuyfoRp0ljU3pSgfg.png" /><figcaption>Docker Overview</figcaption></figure><h3>Up Next</h3><p>we’ll install Docker.But more importantly,we’ll look at what we’re actually installing.Because understanding Docker starts long before running the first container.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb493c5b6c3d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The World Before OS: What Happened When Every Program Was on Its Own]]></title>
            <link>https://medium.com/@pawarmanas47/the-world-before-os-what-happened-when-every-program-was-on-its-own-ac4684400b3e?source=rss-0f408ac2b31a------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac4684400b3e</guid>
            <category><![CDATA[breaking-the-system]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cs-core]]></category>
            <category><![CDATA[operating-systems]]></category>
            <category><![CDATA[computer-science]]></category>
            <dc:creator><![CDATA[Pawarmanas]]></dc:creator>
            <pubDate>Mon, 20 Apr 2026 15:43:11 GMT</pubDate>
            <atom:updated>2026-04-20T15:43:11.933Z</atom:updated>
            <content:encoded><![CDATA[<h4>BREAKING DOWN SYSTEMS →Blog 1</h4><h4>Before operating systems existed, every program had to fight for survival — here’s why that couldn’t last.</h4><h3>🚀 What if your computer had no Operating System?</h3><p>No Windows. No Linux. No macOS. Just you… and raw hardware.</p><p>Sounds absurd, right?</p><p>But let’s think deeper.</p><p>🧨<strong>Imagine this.</strong></p><p>You walk into a<strong> Shared Office</strong>. There’s</p><ul><li>one printer</li><li>one coffee machine</li><li>one whiteboard</li><li>and about twenty people</li></ul><p>— all arriving at the same time, all needing everything at once.</p><p>No manager. No booking system. No turns.</p><p>One person just starts printing 400 pages. Someone else unplugs the printer midway to plug in their laptop. A third person is writing on the whiteboard while someone else erases it. Everyone is acting in their own interest, <strong>completely unaware of each other.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2F9fihqWeFNmYDwy4XPFRg.png" /></figure><h4>This is exactly the problem early computers faced.</h4><p>And it wasn’t just theoretical.</p><p>Without an operating system:</p><ul><li>Applications had to include <strong>hardware-level code inside themselves.</strong></li><li>One program could <strong>take over all resources.</strong></li><li>There was <strong>no memory protection</strong> between programs.</li></ul><blockquote>👉 <em>In simple words</em>: Every program was selfish… and the system had no control.</blockquote><p>Now consider there’s a <strong>coordinator</strong>:</p><p>Who →</p><ul><li>Assigns time slots</li><li>Manages resources</li><li>Ensures fairness</li></ul><p>Suddenly, everything works smoothly 💡.</p><h4>🎯 That “coordinator” is the Operating System.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sPezYqSBAIKRtL4rKxK3EA.png" /><figcaption>OS layer Architecture</figcaption></figure><p>The OS sits between the user’s programs and the raw hardware — and it</p><p>does these things :</p><p>It <strong>abstracts</strong> the hardware. You don’t talk to the printer directly. You talk to the OS, and the OS handles the printer. The complexity is hidden.</p><p>It <strong>manages resources</strong>. CPU time, memory, files, I/O devices — the OS decides who gets what, when, and for how long.</p><p>It <strong>protects</strong>. Program A cannot read Program B’s memory. Not because programs are well-behaved — but because the OS enforces it at the hardware level.</p><h4>So the real reason OS exists is not convenience…</h4><h4>It’s Control.</h4><p>Without control:</p><ul><li>systems become unpredictable</li><li>resources get misused</li><li>programs interfere</li></ul><h4>So , Next time you open an app and everything just works…</h4><blockquote><strong>Remember:</strong><em>There’s an invisible system constantly deciding<br> </em>who gets what, when, and how.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac4684400b3e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>