Dedeepya Sunkara’s Post

One thing I’m learning recently: 👉 DevOps is not just about tools… it’s about automation. While going through Shell Scripting for DevOps, I saw how simple scripts can automate powerful tasks like: 🔹 Server setup and package installation 🔹 Monitoring system performance 🔹 Managing backups and logs 🔹 Automating deployments with tools like Docker, Jenkins, and Kubernetes. What really stood out to me? A few lines of Bash can: ✔ Restart failed services automatically ✔ Monitor CPU, memory, and disk usage ✔ Trigger CI/CD pipelines ✔ Deploy applications without manual intervention For example: 👉 A simple script can check if a service like NGINX is down and restart it instantly 👉 Another script can back up databases daily without human input This made me realize: 👉 The real power in DevOps is automation at scale. 💡 MY TAKEAWAY If you want to get into DevOps: 👉 Learn Linux 👉 Learn Shell scripting 👉 Learn how systems actually work Because: 🚫 Manual work doesn’t scale ✅ Automation does #DevOps #ShellScripting #Linux #Automation #CloudComputing #TechSkills #Engineering #SoftwareEngineering #STEM #CareerGrowth

DevOps Zero to Job-Ready – Day 11/180 | Bash Variables & Script Structure After writing basic scripts earlier, today focuses on understanding how scripts are actually structured. What this covers: * Using variables in Bash * Storing values like names, paths, dates * Basic script structure with `#!/bin/bash` * Making scripts more readable and reusable Example: ```bash #!/bin/bash NAME="DevOps" DATE=$(date) echo "Hello $NAME" echo "Today is $DATE" ``` Key idea: Scripts should not be hardcoded. Using variables makes them flexible and reusable. This is important for: * Deployment scripts * Automation tasks * Config-driven workflows --- Sharing today’s notes. More structured DevOps content available on [www.engidock.com](https://www.engidock.com). --- #EngiDock #DevOps #Linux #SRE #LearningInPublic

🚨 𝗔 𝘀𝗶𝗻𝗴𝗹𝗲 𝘄𝗿𝗼𝗻𝗴 𝗽𝗲𝗿𝗺𝗶𝘀𝘀𝗶𝗼𝗻 𝗰𝗮𝗻 𝗯𝗿𝗲𝗮𝗸 𝗮𝗻 𝗲𝗻𝘁𝗶𝗿𝗲 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝘀𝘆𝘀𝘁𝗲𝗺. Sounds dramatic… but it happens more often than you think. While learning Linux for DevOps, I discovered that many real-world issues are not caused by bugs in code — they’re caused by 𝗶𝗻𝗰𝗼𝗿𝗿𝗲𝗰𝘁 𝗳𝗶𝗹𝗲 𝗽𝗲𝗿𝗺𝗶𝘀𝘀𝗶𝗼𝗻𝘀. 💡 𝘋𝘢𝘺 11 𝘰𝘧 𝘮𝘺 𝘋𝘦𝘷𝘖𝘱𝘴 𝘑𝘰𝘶𝘳𝘯𝘦𝘺 Today I explored two very important Linux commands: 🔐 `𝘤𝘩𝘮𝘰𝘥` 👤 `𝘤𝘩𝘰𝘸𝘯` These commands control 𝘄𝗵𝗼 𝗰𝗮𝗻 𝗮𝗰𝗰𝗲𝘀𝘀, 𝗺𝗼𝗱𝗶𝗳𝘆, 𝗼𝗿 𝗲𝘅𝗲𝗰𝘂𝘁𝗲 𝗳𝗶𝗹𝗲𝘀 𝗼𝗻 𝗮 𝘀𝘆𝘀𝘁𝗲𝗺. And in DevOps, this matters a lot. --- 📖 Imagine this scenario: An application is deployed successfully. But when the service starts… ❌ It cannot read a configuration file ❌ It cannot access a log directory ❌ It fails to start The problem? Not the code. Not the server. 👉 Just 𝘄𝗿𝗼𝗻𝗴 𝗽𝗲𝗿𝗺𝗶𝘀𝘀𝗶𝗼𝗻𝘀. --- 🔹 `𝗰𝗵𝗺𝗼𝗱` — 𝗖𝗵𝗮𝗻𝗴𝗲 𝗙𝗶𝗹𝗲 𝗣𝗲𝗿𝗺𝗶𝘀𝘀𝗶𝗼𝗻𝘀 This command controls what users can do with a file. Example: ``` 𝘤𝘩𝘮𝘰𝘥 755 𝘴𝘤𝘳𝘪𝘱𝘵.𝘴𝘩 ``` This means: ✔ Owner can read, write, execute ✔ Others can read and execute DevOps engineers use this when: • Making deployment scripts executable • Securing configuration files • Controlling access to directories --- 🔹 `𝗰𝗵𝗼𝘄𝗻` — 𝗖𝗵𝗮𝗻𝗴𝗲 𝗙𝗶𝗹𝗲 𝗢𝘄𝗻𝗲𝗿𝘀𝗵𝗶𝗽 Sometimes the issue is not permission… it's ownership. Example: ``` 𝘤𝘩𝘰𝘸𝘯 𝘶𝘣𝘶𝘯𝘵𝘶:𝘶𝘣𝘶𝘯𝘵𝘶 𝘢𝘱𝘱.𝘭𝘰𝘨 ``` This assigns the file to a specific user and group. Very common when working with: ✔ Docker containers ✔ Application logs ✔ Server directories --- 🔥 One thing I learned today: Security in Linux is 𝗻𝗼𝘁 𝗼𝗻𝗹𝘆 𝗮𝗯𝗼𝘂𝘁 𝗳𝗶𝗿𝗲𝘄𝗮𝗹𝗹𝘀 𝗼𝗿 𝗮𝘂𝘁𝗵𝗲𝗻𝘁𝗶𝗰𝗮𝘁𝗶𝗼𝗻. It also starts with 𝗰𝗼𝗿𝗿𝗲𝗰𝘁 𝗳𝗶𝗹𝗲 𝗽𝗲𝗿𝗺𝗶𝘀𝘀𝗶𝗼𝗻𝘀. --- 📌 My biggest takeaway: In DevOps, small details like permissions can decide whether an application runs smoothly… or crashes immediately. And that’s why mastering Linux fundamentals is so important. --- 💬 Quick question for DevOps engineers here: Which permission do you use the most? `𝘤𝘩𝘮𝘰𝘥 755` `𝘤𝘩𝘮𝘰𝘥 777` or something else? Let’s discuss 👇 --- #DevOps #Linux #LinuxPermissions #CloudComputing #DevOpsEngineer #SRE #TechLearning #OpenSource #ITCar

DevOps Zero to Job-Ready – Day 7/180 | Putting It All Together Today felt different. For the past six days, I’ve been learning individual concepts. But today, everything started to connect. Here’s what the journey looked like so far: * Day 1 — Navigating a Linux system * Day 2 — File permissions and access control * Day 3 — Managing running processes * Day 4 — Extracting information using text processing * Day 5 — Writing basic Bash scripts * Day 6 — Connecting to remote servers using SSH What I understood today: These are not separate topics. They all come together in real DevOps work. Example: You connect to a remote server (SSH), check logs (text processing), identify a failing process, fix permissions if needed, and automate the solution using a script. That is a deployment. Six steps. Now the next step is clear: Write a script that does all six. Sharing today’s notes for reference. Also organized structured DevOps notes and scenarios on [www.engidock.com](https://www.engidock.com). #DevOps #Linux #Automation #LearningInPublic

😇 DevOps without CLI 😈 DevOps with CLI Let’s be honest… The moment you move from clicking in the console to typing in the terminal — everything changes. You stop using tools. You start controlling them. Every serious DevOps tool relies on CLI: • Terraform • Ansible • Kubernetes (kubectl) • AWS CLI • Git Because automation doesn’t happen with a mouse — it happens with commands. Why CLI matters: 🧠 Deeper understanding of systems ⚡ Faster execution (1 command > 10 clicks) 🔁 Automation (scripts → CI/CD) 📦 Repeatability (no manual drift) 🌍 Scalability (manage thousands, not just one) GUIs are great for learning and visibility. But they’re not enough. 💡 Real DevOps growth starts when you: • Debug with CLI • Deploy with CLI • Automate with scripts Start early: Learn basic Linux, use CLI alongside consoles, and automate small tasks. The CLI isn’t scary — it’s powerful. And once you’re comfortable… you won’t go back. 😄 #DevOps #Linux #CLI #Automation #CloudEngineering #SRE #Kubernetes

Ever wondered what really powers most of the automation behind the scenes in Linux systems? 👀 Welcome to the world of Shell Scripting — simple, powerful, and a must-have skill for anyone in DevOps, System Admin, or Application Support. 💡 What is Shell Scripting? It’s basically writing a series of commands in a file that the shell can execute automatically — saving time, reducing errors, and making your life easier. 🔹 Basic Building Blocks: ✅ Shebang (#!) Tells the system which interpreter to use Example: "#!/bin/bash" ✅ Variables Store values for reuse "name="Sumit"" "echo $name" ✅ User Input "read user_input" ✅ Conditional Statements (if-else) Make decisions in scripts if [ $num -gt 10 ]; then echo "Greater than 10" fi ✅ Loops (for/while) Repeat tasks efficiently for i in {1..5} do echo $i done ✅ Functions Reusable blocks of code greet() { echo "Hello $1" } greet Sumit ⚙️ Real-Life Use Cases: - Automating backups 📦 - Monitoring server health 🖥️ - Log cleanup & rotation 🧹 - Deployment scripts 🚀 - Cron jobs for scheduled tasks ⏰ 🔥 Why should you learn it? Because in real production environments, automation isn’t optional — it’s survival. Start small. Automate one repetitive task daily. That’s how pros are built. #Linux #ShellScripting #DevOps #Automation #SRE #Learning #TechCareers

🚀 Setting Up Jenkins for CI/CD Pipelines | Day 68/100 – DevOps Journey Today’s task was about setting up a CI/CD server using Jenkins, a core tool in modern DevOps workflows. 🔹 What I did: - Installed Jenkins using apt on the server - Started and verified Jenkins service - Debugged service issues using logs (/var/log/jenkins/jenkins.log) - Completed initial setup via Jenkins UI - Created admin user: ⚙️ Why it matters: - Jenkins is widely used to automate: Build → Test → Deploy pipelines - Reduces manual work and improves delivery speed - Backbone of modern CI/CD systems This marks a step forward into automation and pipeline engineering in DevOps 🚀 Proof of work :- https://lnkd.in/gnBnU_cv #100DaysOfDevOps #DevOps #Jenkins #CICD #Automation #CloudNative #Linux #LearningInPublic #TechCareers #OpenToWork

𝐉𝐞𝐧𝐤𝐢𝐧𝐬 𝐂𝐈/𝐂𝐃 𝐏𝐢𝐩𝐞𝐥𝐢𝐧𝐞, 𝐒𝐢𝐦𝐩𝐥𝐞 & 𝐂𝐥𝐞𝐚𝐫 𝐔𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝𝐢𝐧𝐠| A well-structured CI/CD pipeline is essential for delivering applications faster and more reliably. While working with Jenkins, I realized that a pipeline is not just automation—it’s a defined workflow that brings consistency to software delivery. The process starts with defining the pipeline and agent, where agent any allows execution on any available machine. The environment section helps manage variables like application settings across all stages. At the core are the stages, which handle the complete lifecycle of the application: 👉 Build → Compile and package the code 👉 Test → Validate functionality and quality 👉 Deploy → Release the application (often using Docker) After all stages are completed, the post section runs automatically to take care of important tasks like: 👉 Archiving artifacts 👉 Sending notifications 👉 Performing cleanup This structured approach helps teams deliver software more reliably and efficiently. #Kubernetes #Helm #DevOps #CloudNative #Containers #Pod #YAML #Kubernetes #ZeroToOne #Git #GitHub #Linux #VersionControl #Linux #CICD #Docker #Terraform #Script #AWS #GCP #Azure #SDLC #DevOpsLife #SRE #DevOpsEngineer #jenkins #devops #cicd #automation

Is Jenkins still relevant in 2026? Absolutely. 🚀 Despite the rise of cloud-native CI/CD tools, Jenkins remains a powerhouse for enterprise DevOps. Its unmatched flexibility, massive plugin ecosystem, and robust master-agent architecture make it ideal for complex, hybrid environments. Key advantages: ✅ Pipeline as Code:Version-controlled, reproducible builds via Jenkinsfile. ✅ Scalability:Dynamic agents on Kubernetes ensure efficient resource usage. ✅ Community:Decades of support mean solutions for almost every issue. While it requires maintenance, Jenkins offers control that managed services often lack. It’s not just a legacy tool; it’s a versatile engine for serious automation. Are you sticking with Jenkins or migrating to GitHub Actions/GitLab? Let’s discuss your strategy below! 👇 #DevOps #Jenkins #CICD #Automation #SoftwareEngineering #TechTrends #CloudComputing

I used to think “ls, cd, mkdir” = Linux mastery… until reality hit. A few months ago, I met a student who said: “I’ve learned Linux… but I still can’t solve real DevOps tasks.” That’s when it clicked 👇 Knowing basic commands is NOT enough. Real DevOps starts when you master advanced Linux tools. Let me show you what most beginners miss 👇 6 Powerful Linux Commands Every DevOps Engineer Must Know: find – Locate anything, anytime (by name, type, time) sed – Edit files like a wizard (no manual changes needed) tr – Transform text instantly user management – Add/manage users like a sysadmin file permissions – The backbone of system security awk – Process data like a pro (logs, reports, automation) Example: Instead of manually searching files… You can run: find / -type f -mtime -3 And instantly get files modified in the last 3 days. That’s the difference between: Beginner vs DevOps-ready engineer Here’s the truth: Most courses teach commands. Very few teach how to actually use them in real-world DevOps scenarios. That’s exactly why we built this 👇 New DevOps Batch 15 (Hands-on + Real Projects) https://lnkd.in/gAz8-Mrv Complete Linux (Basic → Advanced) Shell scripting + Automation AWS, Docker, Kubernetes CI/CD pipelines Real-time DevOps use cases Interview preparation If you're serious about becoming a DevOps engineer in 2026: Stop just learning commands Start building real skills Comment "DEVOPS" and I’ll guide you personally #Linux #DevOps #Cloud #AWS #Kubernetes #Docker #SRE #Automation #TechCareers