Docker Cheat Sheet & Revision for DevOps

Day 37 – Docker Revision & Cheat Sheet Instead of learning something new, I focused on: Revising core concepts (images, containers, networking, volumes) Answering quick-fire questions from memory Building a practical Docker cheat sheet (real commands I’ll actually use) Identifying weak areas and revisiting them Checkout my work: https://lnkd.in/g-7SKf2m Check comments for cheat sheet #90DaysOfDevOps #DevOpsKaJosh #TrainWithShubham #Docker #DevOps #CloudComputing #BackendDevelopment #SoftwareEngineering #LearningInPublic #TechJourney #DeveloperLife #CareerGrowth #BuildInPublic

Day 15 of learning Docker — and today, I finally understood what’s happening behind the scenes. 🧠🐳 I used to think building a Docker image was just… one process. But it’s not. 👉 It’s built in layers. Every instruction in a Dockerfile creates a new layer: FROM COPY RUN CMD And Docker is smart. It caches layers. So next time you build — it doesn’t rebuild everything… only what changed. 💥 That’s why Docker builds are fast. 🧠 What I learned today: • What are Docker layers • How layer caching works • Why build order matters • Optimizing Dockerfiles 💡 Realization: Writing a Dockerfile is not just writing steps… it’s about writing them in the right order. Small change → big performance difference. This felt like understanding the engine, not just driving the car. #Docker #DevOps #LearningInPublic #Day15 #DeepLearning

Day 17 of learning Docker — and today, I learned how to not send unnecessary stuff. 📦🚫 Earlier, whenever I built an image… Docker was copying everything into it: node_modules .git folder logs unnecessary files And I didn’t even realize it. Result? ❌ Bigger image ❌ Slower build ❌ Messy container Then I discovered: 👉 .dockerignore It works just like .gitignore. You tell Docker: “Don’t include these files when building the image.” And just like that… ✔ Smaller images ✔ Faster builds ✔ Cleaner containers 🧠 What I learned today: • What is .dockerignore • Why excluding files matters • Reducing build context size • Best practices for clean images 💡 Realization: Optimization isn’t always about adding things… sometimes it’s about removing what you don’t need. #Docker #DevOps #LearningInPublic #Day17 #Optimization

🐳 Learning Docker… I’ve been using Docker for a while, but recently started understanding the basics more clearly. Things like: 1. Images vs Containers 2. Layers and how they affect build time 3. What a registry does 4. Why tags matter Still learning, but it’s starting to make more sense now. I wrote a short blog to capture my understanding: 🔗 https://lnkd.in/gxSG4v_p Would love to hear — what helped you understand Docker better? #Docker #LearningInPublic #DevOps

Day 18 of learning Docker - and today, I focused on doing things better, not just working. ⚡ By now, I can build Docker images. But today I asked: 👉 Are my images actually optimized? Because in real-world projects: Smaller images = faster deployments Cleaner images = fewer issues Efficient builds = better performance So I learned how to optimize Docker images. 🧠 What I learned today: • Use smaller base images (like alpine) • Combine commands to reduce layers • Remove unnecessary files • Use multi-stage builds (from Day 16 😉) • Use .dockerignore (from Day 17 🔥) 💡 Realization: Good Docker users make things work. Great Docker users make them efficient. This felt like connecting all the dots from the past few days. #Docker #DevOps #LearningInPublic #Day18 #Optimization

Hello Everyone 👋 🐳 Continuing My Learning Journey with Docker Basics! As I move forward in my Kubernetes journey, I’ve started revisiting Docker fundamentals to strengthen my foundation in containerization. Understanding Docker is crucial before diving deeper into Kubernetes, and this step is helping me connect the dots better between containers and orchestration. So far, I’ve explored: 🔹 What Docker is and why it’s widely used 🔹 Difference between Images and Containers 🔹 Writing a basic Dockerfile 🔹 Running containers using simple Docker commands 🔹 How Docker helps in maintaining consistency across environments 💡 Key Learning / Insight: One interesting thing I learned is that CMD and ENTRYPOINT instructions do NOT create additional image layers in Docker. They only define how a container runs, unlike RUN instructions which actually add layers during the image build process. This small concept gave me better clarity on how Docker images are optimized and built efficiently 🚀 I’ll keep sharing more learnings and insights as I progress further! #Docker #DevOps #Containerization #LearningInPublic #CloudComputing #Kubernetes

so I'm here thinking I want to learn a language and I've landed on 'go' . I find it easier to relate to Terraform for my own understanding. question: does using a tool like GoLand help the learning or hinder ? I've read the way the IDE works is unparalleled and superior to the free gopls LSP. thought 🤔? #devops #go #learncode

🚀 Mastering Docker CLI just got easier! If you're working with containers, this Docker CLI cheatsheet is a game-changer 💡 From running containers to managing images and cleaning up your system — everything is in one place. Here’s what stood out to me 👇 🔹 Run containers effortlessly with simple commands 🔹 Manage containers like a pro ("docker ps", "docker stop", "docker exec") 🔹 Handle images (pull, push, build) with clarity 🔹 Monitor logs, stats, and system info in real-time 🔹 Clean up unused resources to keep your system optimized 💬 One tip I found super useful: Use "docker run -it" for interactive mode — makes debugging much easier! 📌 Whether you're a beginner or brushing up your skills, having a quick reference like this can save a lot of time. 👉 What’s your most-used Docker command? Drop it in the comments! #Docker #DevOps #CloudComputing #BackendDevelopment #SoftwareEngineering #Learning #TechTips #Developers

🚀 Docker Day 4 — Understanding Docker Layers (Why Images Are Fast ⚡) Continuing my Docker journey, today I explored one of the most important concepts in Docker — Layers. 👉 What are Docker Layers? Every Docker image is built in layers. Each instruction in a Dockerfile creates a new layer. 👉 Why this matters? Docker caches these layers, so if something doesn’t change, it reuses existing layers instead of rebuilding everything. 👉 Example understanding: If I install dependencies in one layer and change only my app code later, Docker won’t reinstall everything again — it will reuse the cached layer. 💡 Big Learning: Efficient layering = faster builds + better performance 👉 Also explored what to learn next: 👉 Writing Dockerfile (to create custom images) 👉 Persisting data using volumes 👉 Optimizing builds using layer caching 📌 Key Takeaway: Docker is not just about containers — it’s about building optimized, reusable environments. This concept made me realize why Docker is so powerful in real-world projects and CI/CD pipelines. Learning in public 🚀 #Docker #DevOps #WebDevelopment #LearningInPublic #DevJourney

𝐃𝐚𝐲 3: 𝐃𝐨𝐜𝐤𝐞𝐫𝐟𝐢𝐥𝐞𝐬 𝐄𝐱𝐩𝐥𝐚𝐢𝐧𝐞𝐝 𝐋𝐢𝐤𝐞 𝐍𝐞𝐯𝐞𝐫 𝐁𝐞𝐟𝐨𝐫𝐞 – 𝐁𝐮𝐢𝐥𝐝, 𝐎𝐩𝐭𝐢𝐦𝐢𝐳𝐞 𝐰𝐢𝐭𝐡 𝐌𝐮𝐥𝐭𝐢-𝐒𝐭𝐚𝐠𝐞 𝐁𝐮𝐢𝐥𝐝𝐬 & 𝐑𝐞𝐝𝐮𝐜𝐞 𝐈𝐦𝐚𝐠𝐞 𝐒𝐢𝐳𝐞 𝐛𝐲 𝐔𝐩 𝐭𝐨 70% 🐳 𝑶𝒏 𝑫𝒂𝒚 1, 𝒘𝒆 𝒓𝒂𝒏 𝒄𝒐𝒏𝒕𝒂𝒊𝒏𝒆𝒓𝒔. 𝑶𝒏 𝑫𝒂𝒚 2, 𝒘𝒆 𝒖𝒏𝒅𝒆𝒓𝒔𝒕𝒐𝒐𝒅 𝒊𝒎𝒂𝒈𝒆𝒔. But today… Everything changes. 👉 What if the exact image you need doesn’t exist? 👉 What if you want full control over your environment? That’s where Dockerfiles come in. In Day 3 of #20DaysOfDocker, we stop relying on others and start building our own images from scratch. 👉 What you’ll learn: What Dockerfiles really are (more than just a config file) All essential instructions (FROM, RUN, COPY, CMD, etc.) How to build custom images step by step Multi-stage builds (build big → ship small ) Best practices used in real production systems Optimization techniques to reduce image size dramatically 💡 The big insight: A Dockerfile is a recipe for consistency. Same code + same Dockerfile = same environment anywhere. No more “it works on my machine.” ❌ 𝐇𝐚𝐧𝐝𝐬-𝐨𝐧 (𝐫𝐞𝐚𝐥 𝐥𝐞𝐚𝐫𝐧𝐢𝐧𝐠): Write your first Dockerfile Build your own image Optimize it step by step 𝐔𝐬𝐞 𝐦𝐮𝐥𝐭𝐢-𝐬𝐭𝐚𝐠𝐞 𝐛𝐮𝐢𝐥𝐝𝐬 𝐭𝐨 𝐜𝐮𝐭 𝐬𝐢𝐳𝐞 𝐛𝐲 𝐮𝐩 𝐭𝐨 70% ⚡ 𝐖𝐡𝐲 𝐭𝐡𝐢𝐬 𝐦𝐚𝐭𝐭𝐞𝐫𝐬: Smaller images = faster deployments Optimized builds = lower costs Clean structure = easier maintenance Real skill = real DevOps growth 𝐁𝐲 𝐭𝐡𝐞 𝐞𝐧𝐝 𝐨𝐟 𝐃𝐚𝐲 3: 𝐘𝐨𝐮’𝐫𝐞 𝐧𝐨𝐭 𝐣𝐮𝐬𝐭 𝐫𝐮𝐧𝐧𝐢𝐧𝐠 𝐜𝐨𝐧𝐭𝐚𝐢𝐧𝐞𝐫𝐬… 𝐘𝐨𝐮’𝐫𝐞 𝐞𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠 𝐭𝐡𝐞𝐦. 👉 𝐒𝐭𝐚𝐫𝐭 𝐃𝐚𝐲 3 𝐡𝐞𝐫𝐞: https://lnkd.in/dtVn3ieP Tomorrow, we go even deeper. Let’s keep building. 🐳 #Docker #DevOps #LearningInPublic #OpenSource #BackendDevelopment #CloudComputing #SoftwareEngineering #TechCommunity