DEV Community: manish rajwar

DevOps Week 6 and 7: Chart Plan and Execution

manish rajwar — Tue, 28 Jan 2025 07:48:10 +0000

In the past two weeks, I’ve focused on diving deeper into Ansible, automating tasks, and improving my understanding of various key concepts and tools. Here’s a simple breakdown of what I’ve learned and implemented during this time:

Exploring Ansible => Understanding What It Is and How It Works
Ansible is an automation tool that helps in managing and provisioning infrastructure. It uses simple YAML files, called playbooks, to define tasks and automate the deployment and configuration of systems.
I learned about its declarative approach, where you specify the desired state of your system and Ansible ensures that it reaches that state without worrying about the intermediate steps.
Learning Password-less Authentication and Its Importance =>
Password-less authentication allows you to log into servers or instances without entering a password. This improves security and simplifies automation tasks since you don’t need to manually input credentials.
The importance of password-less authentication lies in the fact that it minimizes the risk of human error, enhances security, and is essential when automating tasks like provisioning and managing servers through Ansible.
Exploring Ansible Galaxy and Docs => Ansible Galaxy is a community-driven hub where you can find reusable Ansible roles, collections, and modules. I explored it to understand how I can use pre-built solutions in my own projects.
The Ansible documentation was an invaluable resource throughout my learning process, providing detailed guides and modules to help me with tasks such as provisioning EC2 instances and automating configurations.
Learning Ansible Playbook Structure => I learned how to write Ansible playbooks, which are simple YAML files that define tasks and configurations for multiple servers or systems.
A playbook typically includes the following:
Hosts: Specifies the target servers.
Tasks: Defines the actions to perform on the target hosts.
Handlers: Actions that are triggered based on conditions.
Variables: For managing dynamic data.
Understanding this structure helped me build and execute various playbooks for automating tasks.
Creating Playbooks => I created several Ansible playbooks to automate various tasks, including provisioning EC2 instances, setting up password-less authentication, and automating specific tasks on instances. This hands-on practice helped reinforce my understanding of how to use Ansible effectively.
Project Tasks => I worked on a project where I automated the provisioning and configuration of EC2 instances with the following tasks:

Task 1: Create Three EC2 Instances (2 Ubuntu, 1 AWS Linux) Using Loops

I used Ansible's EC2 module and loops to provision two Ubuntu instances and one AWS Linux instance. The loop allowed me to simplify the process of creating multiple instances with similar configurations.
Task 2: Set Up Password-less Authentication on All Instances

I automated the process of setting up password-less authentication (using SSH keys) for all the instances. This was essential for allowing the Ansible playbooks to run without requiring passwords.
Task 3: Automate Shutdown on Ubuntu Instances Using Condition (When Condition)

I created a playbook to automatically shut down only the Ubuntu instances, using the when condition to target just those instances.

Reading About Vault and Inventory.ini File => I read about Vault, which is used to securely store sensitive data like passwords or private keys in Ansible.
I also explored the inventory.ini file, which is used to define groups of servers and their configurations. It’s an essential component of managing multiple hosts in Ansible playbooks.
GitHub Project Link => I’ve shared my project on GitHub, where you can find the playbooks and the configurations I used: GitHub Project - Provisioning and Configuration Management
Resources Used

Ansible Documentation: I referred to the official Ansible documentation to understand modules like ec2 and other relevant tools: Ansible EC2 Module Documentation

Ansible Galaxy: I explored various roles and modules on Ansible Galaxy to improve my automation tasks: Ansible Galaxy - AWS Roles

YouTube Playlist: I used this YouTube playlist to follow along and learn from video tutorials:

Conclusion
The past two weeks have been incredibly productive as I explored Ansible in-depth, understood its core concepts, and implemented them in real-world tasks. I’m excited to continue building my skills with Ansible and applying them to more complex projects. This experience has given me a solid foundation for automating infrastructure and configurations, which is a key aspect of DevOps.

Feel free to explore my GitHub project and resources I used during this learning process. I’ll continue to update my journey as I progress further!

My DevOps Journey: Weeks 3 to 5 Recap

manish rajwar — Thu, 02 Jan 2025 08:02:56 +0000

As part of my journey to becoming a DevOps engineer, I’ve delved into various tools and technologies over the past few weeks. This article captures the milestones and learning experiences I’ve had in Weeks 3, 4, and 5. From mastering AWS fundamentals to hands-on Bash scripting projects, this phase has been both challenging and rewarding.

Week 3: Exploring AWS Essentials

I began my AWS learning journey with a focus on understanding and using key AWS services. Here’s a summary of what I learned:

Amazon EC2 (Elastic Compute Cloud):EC2 instances are virtual servers in the cloud. I learned how to launch, configure, and manage instances, gaining insights into instance types and use cases. AWS documentation and this YouTube playlist were invaluable resources.

EBS (Elastic Block Store):EBS provides persistent storage for EC2 instances. I explored:

EBS Volumes: Creating and attaching volumes to instances for durable storage.

Snapshots: Creating backups of EBS volumes to ensure data recovery.

Security Groups: Security groups act as virtual firewalls for EC2 instances. I learned how to:

Configure inbound and outbound rules.

Restrict access based on IP addresses and protocols.

Amazon Machine Image (AMI):I discovered how AMIs provide templates for EC2 instances, enabling efficient replication and deployment of server configurations.

Load Balancers: I explored different types of load balancers:

Classic Load Balancer (CLB): Balances traffic at the network and transport layers.

Application Load Balancer (ALB): Routes traffic based on application-level protocols.

Network Load Balancer (NLB): Optimized for high-performance network-level traffic.

These foundational skills are pivotal for a DevOps role. AWS documentation and youtube link :

Week 4: Following the Zero to Hero DevOps Journey

In Week 4, I immersed myself in the Zero to Hero DevOps Journey. This playlist help me in revising previous topic.
resources: youtube:

Week 5: Bash Scripting and Hands-on Projects

In Week 5, I transitioned to Bash scripting, focusing on creating practical automation scripts. Here are the projects I worked on:

AWS Resources Tracker:

Purpose: To track and list the current AWS resources in an account.

Features:

Displayed the count of EC2 instances, EBS volumes, S3 buckets, and Lambda functions.

Automated retrieval of resource details using the AWS CLI.

GitHub Collaborators Tracker:

Purpose: To list all collaborators on our organization’s GitHub repositories.

Features:

Extracted usernames of active collaborators.

Used the GitHub API for data retrieval.

Both projects reinforced my Bash scripting skills and demonstrated how automation can simplify DevOps tasks. These experiences were instrumental in enhancing my problem-solving abilities.

Resources I Used

AWS Documentation: An official and comprehensive guide for all AWS services.

AWS YouTube Playlist:

gitHub:

This journey is a testament to the power of consistent learning and hands-on practice. I’m excited to continue this path toward becoming a skilled DevOps engineer.

DevOps Learning Journey: Week 2 Recap

manish rajwar — Wed, 11 Dec 2024 03:51:21 +0000

As part of my ongoing journey to master DevOps, Week 2 was an incredibly productive and enlightening experience. This week, I focused on two critical areas that are essential for any DevOps professional: advanced Bash scripting and an introduction to Docker basics. Here’s a detailed breakdown of what I learned and the resources that helped me along the way.

Advanced Bash Scripting: Mastering Conditionals and Loops

Bash scripting is a foundational skill for automating repetitive tasks and managing servers efficiently. Building on my Week 1 knowledge, I delved deeper into advanced scripting concepts, particularly focusing on:

Conditionals:

I learned how to effectively use if-else statements to control the flow of scripts based on various conditions.

I explored the case statement, a versatile tool for handling multiple scenarios with concise code.

Practical Application: I created a script to automate a basic file management system. Depending on the input, the script checks whether a file or directory exists, creates new directories, or deletes files.

Loops:

Mastered for, while, and until loops to iterate over files, directories, and numeric ranges.

Used nested loops to handle more complex scenarios, like processing multiple files and generating reports.

Practical Application: One of the tasks I automated involved renaming files in a directory by appending timestamps to ensure unique names.

Functions and Error Handling:

Learned to modularize scripts using functions for reusability and maintainability.

Added error handling mechanisms to ensure the scripts run smoothly even when unexpected situations arise.

Resource: A significant part of my learning came from this YouTube playlist that covers Bash scripting in depth. It offered a perfect blend of theory and hands-on examples to solidify my understanding.

link:

Docker Basics: Images, Containers, and Management

Docker is a game-changer in modern software development and deployment. Understanding its core concepts is crucial for containerization and orchestration. This week, I got a solid introduction to:

What is Docker?

Docker simplifies application deployment by using containers that package the code, dependencies, and environment configurations.

I learned the distinction between images (blueprints for containers) and containers (running instances of images).

Essential Commands:

Creating Images: I practiced building custom Docker images using Dockerfile.

Managing Containers:

Starting and stopping containers with docker run and docker stop.

Removing unnecessary containers and images using docker rm and docker rmi.

Inspecting Containers: Used commands like docker ps to list running containers and docker inspect to examine detailed container metadata.

Practical Tasks:

Created and managed a simple web server inside a Docker container.

Experimented with mounting volumes to share data between the host and the container.

Learned how to network multiple containers for a basic microservices setup.

Resource: This YouTube playlist was instrumental in breaking down Docker’s complexity into digestible modules. From the installation process to hands-on demonstrations, it covered everything a beginner needs.

Reflections and Next Steps

The second week of my DevOps learning journey was not just about acquiring technical skills but also about building confidence in applying them. Bash scripting honed my automation abilities, while Docker introduced me to containerized environments, a must-have in modern DevOps practices.

As I move forward, I plan to:

Continue exploring advanced Bash scripting concepts, such as process management and cron jobs.

Dive deeper into Docker, focusing on Docker Compose for multi-container applications.

Share my projects and scripts on GitHub to track my progress and gather feedback.

link:

"Week 1: My Journey into DevOps – Milestones Achieved"

manish rajwar — Sun, 01 Dec 2024 06:45:33 +0000

Today i have completed the week 1 journey to devops. This week i learn about bash scripting. Topic I cover this weeek are:

Basic Linux commands
set and unset a variables
Using expr commands to evaluate the expression
use of Shebang in shell scripting
Overview of Vim editor and its commands
Understand File permission (chmod and chown)
unix process controls commands
Foreground and Background process shifting
Loops and if-else conditions

Resources:

Youtube: https://www.youtube.com/playlist? list=PL6XT0grm_TfjQtYPgOADkMTNLsdjbXY9v
AI Tools like chatgpt, gemini for practice.
Reading Blogs from dev.io

DevOps #LearningJourney #BashScripting #LinuxCommands #Automation

Devops Week 1

manish rajwar — Mon, 25 Nov 2024 17:31:38 +0000

🌟 Week 1: Learning Bash Scripting 🌟

This week, I started my journey to master DevOps by learning the basics of Bash scripting. Here’s what I covered:

Using commands like echo, nano, and touch
Understanding the shebang (#!) in scripts
Learning about file permissions and how to manage them
Exploring beginner-level Unix process control commands
I also found an amazing video that helped me get started with scripting: Bash Scripting Tutorial. It’s beginner-friendly and highly recommended!

To practice these concepts, I used ChatGPT as a learning tool, which made it easier to understand and experiment with commands.

Excited to continue my DevOps learning journey! Let me know if you’re also learning or have tips to share. 😊