DEV Community: Kanav Gathe

DevOps Planning to Production Day 1 of 24 : Getting Started with Red Hat Linux

Kanav Gathe — Wed, 27 Nov 2024 14:07:50 +0000

Introduction to Red Hat Linux

Think of an operating system like a conductor in an orchestra, coordinating all the different instruments (hardware components) to create a harmonious performance. Red Hat Linux is a professional-grade conductor, known for its reliability and enterprise support.

Red Hat Linux is a specialized version of Linux designed for business environments. Imagine you're building a house - while regular Linux distributions might be like basic building tools from a hardware store, Red Hat Linux is like having professional-grade construction equipment with a dedicated support team.

Key features that make Red Hat Linux special:

Enterprise Support: You have access to professional help 24/7, like having an expert on call.
Long-term Stability: Updates and security patches continue for up to 10 years, ensuring your system stays secure.
Certified Software Compatibility: Programs are thoroughly tested to work together, like pieces of a puzzle designed to fit perfectly.
Security Features: Built-in protection mechanisms, like having a state-of-the-art security system for your house.

File System Management

The Linux file system is organized like a tree, starting from a single point called the "root" directory (/). Let's understand each major directory and its purpose:

/ (Root Directory)
│
├── /home          # User personal directories (like individual bedrooms)
├── /etc           # System configuration files (like the house's control panel)
├── /var           # Variable data like logs (like a diary of system events)
├── /bin           # Essential commands (like basic household tools)
├── /usr           # User programs (like entertainment systems)
├── /tmp           # Temporary files (like a scratch pad)
└── /boot          # Files needed to start the system (like startup instructions)

Let's explore how to manage this file system with practical examples:

# Creating directories (like creating rooms in a house)
mkdir -p /home/projects/website
# The -p flag creates parent directories if they don't exist

# Moving files (like moving furniture between rooms)
mv /home/old_documents/* /home/archive/

# Copying files (like making duplicates of important documents)
cp -r /etc/httpd/conf/ /etc/httpd/conf.backup/
# The -r flag copies directories recursively

# Finding files (like searching for something in your house)
find /home -name "*.pdf" -mtime -7
# This finds all PDF files modified in the last 7 days

User and Group Administration

Managing users and groups in Linux is like managing employees in a company. Let's explore this with practical examples:

# Creating a new user (like hiring a new employee)
useradd -m -s /bin/bash john
# -m creates a home directory
# -s sets their default shell

# Setting a password
passwd john

# Creating a group (like creating a department)
groupadd developers

# Adding a user to a group (like assigning someone to a department)
usermod -aG developers john
# -a means append
# -G specifies the group

# Setting up project permissions
mkdir /projects/webapp
chown john:developers /projects/webapp
chmod 775 /projects/webapp

Understanding file permissions:

Read (r): Like being able to view a document (4 in numeric notation)
Write (w): Like being able to edit a document (2 in numeric notation)
Execute (x): Like being able to run a program (1 in numeric notation)

Example permission settings:

chmod 755 script.sh
# 7 (owner): read + write + execute (4+2+1)
# 5 (group): read + execute (4+1)
# 5 (others): read + execute (4+1)

Package Management with YUM

YUM (Yellowdog Updater Modified) is like a smart package delivery service for your system. It handles:

Installing new software
Updating existing software
Removing unwanted software
Managing dependencies (other software needed for programs to work)

Common YUM commands with real-world examples:

# Updating the entire system
yum update -y
# The -y flag automatically answers "yes" to prompts

# Installing a web server
yum install httpd php mysql-server -y
# This installs multiple packages at once

# Searching for packages
yum search "web server"
# Shows all packages related to web servers

# Removing packages
yum remove unused-package -y

# Cleaning up
yum clean all
# Removes temporary files and cached data

System Services and Systemd

Systemd is like a master control panel for your system services. Here's how to manage services:

# Starting a service (like turning on an appliance)
systemctl start httpd

# Checking service status
systemctl status httpd
# Shows if the service is running and recent log entries

# Enabling service to start at boot
systemctl enable httpd
# Like setting an appliance to turn on automatically

# Restarting a service
systemctl restart httpd

# Viewing service logs
journalctl -u httpd
# Shows detailed logs for the service

Networking Configuration

Understanding networking in Linux is like understanding how mail gets delivered. Let's break it down:

Basic Network Configuration

# Viewing network interfaces
ip addr show
# Shows all network interfaces and their IP addresses

# Configuring a network interface
nmcli con mod eth0 \
  ipv4.addresses "192.168.1.100/24" \
  ipv4.gateway "192.168.1.1" \
  ipv4.dns "8.8.8.8"
# Like setting up a new mailing address and route

# Testing network connectivity
ping -c 4 google.com
# Sends test packets to check connection

Understanding IP and Netmask

An IP address is like a street address, and a netmask defines the neighborhood:

# Example IP configuration
ip addr add 192.168.1.100/24 dev eth0
# /24 means the first 24 bits define the network (like the street)
# The remaining 8 bits are for individual addresses (like house numbers)

Security and Permissions

Security in Linux is like having multiple layers of protection in a building:

Basic Security Configuration

# Setting up a basic firewall
firewall-cmd --permanent --add-service=http
firewall-cmd --permanent --add-service=https
firewall-cmd --reload
# Like setting up security checkpoints

# Checking for open ports
ss -tuln
# Shows which ports are listening for connections

# Setting up SELinux (Security-Enhanced Linux)
setenforce 1
# Enables strict security policies

System Performance Monitoring

Monitoring your system is like keeping track of a car's dashboard indicators:

# Real-time system monitoring
top
# Shows CPU, memory, and process information

# Disk usage monitoring
df -h
# Shows disk space usage in human-readable format

# Memory usage
free -m
# Shows memory usage in megabytes

# Creating a monitoring script
cat << 'EOF' > /usr/local/bin/monitor.sh
#!/bin/bash
while true; do
    echo "=== System Status ==="
    date
    echo "CPU Usage:"
    top -bn1 | grep "Cpu(s)"
    echo "Memory Usage:"
    free -m
    echo "Disk Usage:"
    df -h /
    sleep 60
done
EOF
chmod +x /usr/local/bin/monitor.sh

Storage Management

Managing storage in Linux is like organizing a warehouse:

# Creating a new partition
fdisk /dev/sdb
# Interactive tool for partition management

# Creating a filesystem
mkfs.xfs /dev/sdb1
# Like preparing a storage area for use

# Mounting storage
mount /dev/sdb1 /data
# Making the storage accessible

# Automatic mounting (in /etc/fstab)
echo "/dev/sdb1 /data xfs defaults 0 0" >> /etc/fstab
# Ensures storage is mounted at boot

Backup and Restore

Implementing a reliable backup system is crucial. Here's a comprehensive backup script:

#!/bin/bash

# Configuration
BACKUP_DIR="/backup"
SOURCE_DIRS=("/etc" "/home" "/var/www")
DATE=$(date +%Y%m%d)
RETENTION_DAYS=30

# Create backup directory
mkdir -p "$BACKUP_DIR"

# Backup function
backup_directory() {
    local source_dir="$1"
    local backup_name="$(basename $source_dir)_$DATE.tar.gz"

    echo "Backing up $source_dir..."
    tar -czf "$BACKUP_DIR/$backup_name" "$source_dir"

    if [ $? -eq 0 ]; then
        echo "Backup of $source_dir completed successfully"
    else
        echo "Backup of $source_dir failed"
    fi
}

# Perform backups
for dir in "${SOURCE_DIRS[@]}"; do
    backup_directory "$dir"
done

# Clean old backups
find "$BACKUP_DIR" -type f -mtime +$RETENTION_DAYS -delete

echo "Backup process completed"

Day 15/90: Python Basics for DevOps Engineers 🐍 #90DaysOfDevOps

Kanav Gathe — Wed, 23 Oct 2024 20:48:22 +0000

Day 15: Python Basics for DevOps Engineers 🚀

Hello DevOps enthusiasts! 👋 Welcome to Day 15 of the #90DaysOfDevOps challenge. Today, we're exploring Python fundamentals essential for DevOps.

Python Installation 🔧

Ubuntu Installation

# Install Python
sudo apt update
sudo apt install python3

# Verify installation
python3 --version

Python Data Types 📝

1. Numbers

# Integer
server_count = 42

# Float
cpu_usage = 85.5

# Complex
complex_number = 1 + 2j

2. Strings

# Single line string
hostname = 'web-server-01'

# Multi-line string
description = '''This is a
multi-line description
of our server'''

# String operations
print(hostname.upper())
print(hostname.split('-'))

3. Lists (Mutable)

# Server list
servers = ['web-01', 'app-02', 'db-01']

# List operations
servers.append('cache-01')
servers.remove('db-01')
print(servers[0])  # First server

4. Tuples (Immutable)

# Version info
version = ('Ubuntu', 20, 'LTS')
os_name, version_num, release_type = version

5. Dictionaries

# Server details
server_info = {
    'hostname': 'web-01',
    'ip': '192.168.1.100',
    'status': 'running',
    'ram_gb': 16
}

# Access data
print(server_info['hostname'])
print(server_info.get('status'))

6. Sets

# Unique ports
active_ports = {80, 443, 22, 3306}
active_ports.add(8080)

7. Boolean

is_running = True
has_backup = False

DevOps Example 🛠️

def check_server_status(servers):
    """Monitor server status"""
    status = {}
    for server in servers:
        # Simulate status check
        status[server] = 'running' if len(server) % 2 == 0 else 'stopped'
    return status

# Usage
servers = ['web-01', 'app-02', 'db-01', 'cache-02']
server_status = check_server_status(servers)

for server, state in server_status.items():
    print(f"Server {server} is {state}")

Key Takeaways 💡

Python is essential for DevOps automation
Multiple data types serve different purposes
Lists and dictionaries are commonly used in DevOps
Python's simplicity makes automation easier
Understanding data types is fundamental

Practical Uses in DevOps 🔨

Script automation
Log parsing
API interactions
Configuration management
Monitoring and alerts
Data processing
Infrastructure automation

Python #DevOps #Automation #Programming #90DaysOfDevOps

This is Day 15 of my #90DaysOfDevOps journey. Keep coding and automating!

Day 14/90: Essential Linux & Git-GitHub Cheat Sheet 📝 #90DaysOfDevOps

Kanav Gathe — Wed, 23 Oct 2024 20:47:26 +0000

Day 14: Linux & Git-GitHub Cheat Sheet 🚀

Hello DevOps enthusiasts! 👋 Welcome to Day 14 of the #90DaysOfDevOps challenge. Today, I'm sharing a comprehensive cheat sheet of essential commands we've learned so far.

Linux Commands 🐧

File Operations

# Navigation
pwd                     # Current directory
ls                      # List files
ls -la                  # List detailed including hidden
cd directory            # Change directory
cd ..                   # Go up one level
cd ~                    # Go to home

# File Management
touch file.txt          # Create empty file
mkdir directory         # Create directory
cp source dest          # Copy
mv source dest          # Move/rename
rm file                 # Remove file
rm -rf directory        # Remove directory

File Content

# Viewing Content
cat file                # Display file content
head -n N file          # Show first N lines
tail -n N file          # Show last N lines
grep pattern file       # Search in file
wc file                # Line/word/char count

# Editing
nano file              # Text editor
vi/vim file            # Advanced editor

Permissions

# Changing Permissions
chmod 755 file         # Set permissions
chmod u+x file         # Add execute permission
chown user:group file  # Change ownership

# ACL
getfacl file          # Get ACL permissions
setfacl -m u:user:rw  # Set ACL permissions

System

# Process Management
ps aux                # List processes
top                   # System monitor
kill PID              # Kill process

# Package Management
apt update            # Update package list
apt install pkg       # Install package
systemctl status svc  # Check service status

Git Commands 🌿

Basic Operations

# Repository Setup
git init              # Initialize repository
git clone URL         # Clone repository
git remote add origin URL  # Add remote

# Daily Commands
git status            # Check status
git add file          # Stage changes
git commit -m "msg"   # Commit changes
git push origin branch # Push changes
git pull              # Update local repo

Branching

# Branch Management
git branch            # List branches
git branch name       # Create branch
git checkout branch   # Switch branch
git checkout -b name  # Create & switch
git merge branch      # Merge branch

# Advanced Operations
git rebase main       # Rebase to main
git cherry-pick commit # Pick specific commit
git stash             # Stash changes

History & Changes

# History
git log               # View history
git log --oneline     # Compact history
git blame file        # Show who changed what

# Undoing Changes
git reset HEAD~1      # Undo last commit
git revert commit     # Revert commit
git checkout -- file  # Discard changes

Quick Reference Tips 💡

Use tab completion
Check command history with history
Use man command for help
Always verify before destructive operations
Keep repositories clean
Make meaningful commit messages
Branch names should be descriptive

Key Takeaways 🎯

Keep commands handy for quick reference
Practice commands regularly
Understand the purpose of each command
Know when to use which command
Backup before major operations

Linux #Git #DevOps #CheatSheet #90DaysOfDevOps

This is Day 14 of my #90DaysOfDevOps journey. Keep this cheat sheet handy!

Day 13/90: Advanced Git & GitHub for DevOps Engineers 🌲 #90DaysOfDevOps

Kanav Gathe — Wed, 23 Oct 2024 20:41:59 +0000

Day 13: Advanced Git Operations 🚀

Hello DevOps enthusiasts! 👋 Welcome to Day 13 of the #90DaysOfDevOps challenge. Today, we're exploring advanced Git operations.

Task Solutions 💻

Task 1: Feature Development with Branches

1. Create Branch and Add Feature

# Create and switch to new branch
git checkout -b dev

# Add initial content
echo "This is the first feature of our application" > Devops/Git/version01.txt
git add .
git commit -m "Added new feature"

# Push to GitHub
git push origin dev

2. Add Multiple Features

# Feature 2
echo "This is the bug fix in development branch" >> Devops/Git/version01.txt
git commit -am "Added feature2 in development branch"

# Feature 3
echo "This is gadbad code" >> Devops/Git/version01.txt
git commit -am "Added feature3 in development branch"

# Feature 4
echo "This feature will gadbad everything from now" >> Devops/Git/version01.txt
git commit -am "Added feature4 in development branch"

3. Revert Changes

# Revert to previous state
git revert HEAD~2

Task 2: Branch Operations

1. Create Multiple Branches

# Create branches
git branch feature1
git branch feature2

2. Merge Changes

# Switch to main and merge
git checkout main
git merge dev

3. Rebase Example

# Rebase feature branch
git checkout feature1
git rebase main

Common Git Operations 🔧

Reset vs Revert

# Reset (changes history)
git reset --hard HEAD~1

# Revert (creates new commit)
git revert HEAD

Merge vs Rebase

# Merge (creates merge commit)
git checkout main
git merge feature

# Rebase (linear history)
git checkout feature
git rebase main

Key Takeaways 💡

Branches enable parallel development
Revert safely undoes changes
Reset modifies history
Merge preserves complete history
Rebase creates linear history
Choose right operation for situation

Git #DevOps #GitHub #BranchingStrategy #90DaysOfDevOps

This is Day 13 of my #90DaysOfDevOps journey. Keep branching and merging!

Day 12/90: Git & GitHub Fundamentals for DevOps Engineers 🌿 #90DaysOfDevOps

Kanav Gathe — Wed, 23 Oct 2024 20:40:29 +0000

Day 12: Git & GitHub for DevOps Engineers 🚀

Hello DevOps enthusiasts! 👋 Welcome to Day 12 of the #90DaysOfDevOps challenge. Today, we're diving into Git and GitHub fundamentals.

Core Concepts 📝

What is Git?

Git is a distributed version control system that helps track changes in source code during software development. It enables:

Version tracking
Collaborative development
Code history maintenance
Branch management
Conflict resolution

Main Branch vs Master Branch

Both serve as the default branch
Main is the new standard (more inclusive)
Functionally identical
Can configure default when initializing repository

Git vs GitHub

Git:
- Version control system
- Runs locally
- Manages source code
- Command-line tool

GitHub:
- Web-based hosting service
- Cloud platform
- Provides collaboration features
- Has web interface

Task Solutions 💻

1. Git Configuration

# Set username and email
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

2. Repository Setup

# Create and initialize repository
mkdir DevOps
cd DevOps
git init

# Create and add content
mkdir Git
echo "Initial content" > Git/Day-02.txt

# Stage and commit
git add .
git commit -m "Initial commit"

# Connect to GitHub
git remote add origin https://github.com/username/DevOps.git
git push -u origin main

Local vs Remote Repository 🔄

Local Repository:

# Initialize local
git init
git add .
git commit -m "message"

Remote Repository:

# Connect and push
git remote add origin <url>
git push -u origin main

# Verify remote
git remote -v

Key Takeaways 💡

Git tracks code changes efficiently
Local and remote repos serve different purposes
Proper configuration is essential
Regular commits maintain clean history
Remote connection enables collaboration

Git #DevOps #GitHub #VersionControl #90DaysOfDevOps

This is Day 12 of my #90DaysOfDevOps journey. Keep versioning and collaborating!

Day 11/90: Error Handling in Shell Scripts 🛡️ #90DaysOfDevOps

Kanav Gathe — Wed, 23 Oct 2024 20:38:06 +0000

Day 11: Error Handling in Shell Scripts 🚀

Hello DevOps enthusiasts! 👋 Welcome to Day 11 of the #90DaysOfDevOps challenge. Today, we're diving into error handling in shell scripts.

Task Solutions 💻

1. Exit Status Checking

#!/bin/bash

# Create directory and check status
mkdir testdir
if [ $? -ne 0 ]; then
    echo "Failed to create directory"
    exit 1
fi
echo "Directory created successfully"

2. If Statement Error Checking

#!/bin/bash

# Multiple commands with error checking
if mkdir -p testdir; then
    if touch testdir/testfile; then
        echo "File created successfully"
    else
        echo "Failed to create file"
        exit 1
    fi
else
    echo "Failed to create directory"
    exit 1
fi

3. Using Trap for Cleanup

#!/bin/bash

# Create temporary file
temp_file=$(mktemp)

# Set trap for cleanup
trap 'rm -f "$temp_file"' EXIT

echo "Working with temporary file"
# Script exits and temp file is removed automatically

4. Error Redirection

#!/bin/bash

# Redirect errors to file
cat nonexistent_file.txt 2> error.log

5. Custom Error Messages

#!/bin/bash

process_file() {
    if [ ! -f "$1" ]; then
        echo "Error: File $1 does not exist"
        exit 1
    fi
    echo "Processing file $1"
}

Key Takeaways 💡

Exit status checks prevent cascading failures
Traps ensure cleanup on script exit
Error redirection helps in logging
Custom messages improve debugging
Proper error handling is crucial for reliability

Bash #DevOps #ErrorHandling #Linux #90DaysOfDevOps

This is Day 11 of my #90DaysOfDevOps journey. Keep handling those errors!

Day 10/90: Log Analyzer and Report Generator 📊 #90DaysOfDevOps

Kanav Gathe — Wed, 23 Oct 2024 20:37:40 +0000

Day 10: Log Analyzer and Report Generator 🚀

Hello DevOps enthusiasts! 👋 Welcome to Day 10 of the #90DaysOfDevOps challenge. Today, we're creating a log analysis tool.

Log Analyzer Script 💻

#!/bin/bash

# Check arguments
if [ $# -ne 1 ]; then
    echo "Usage: $0 <log_file>"
    exit 1
fi

log_file="$1"
report_file="report_$(date +%Y%m%d_%H%M%S).txt"

# Check if log file exists
if [ ! -f "$log_file" ]; then
    echo "Error: Log file not found"
    exit 1
fi

# Generate report
{
    echo "Log Analysis Report"
    echo "==================="
    echo "Date: $(date)"
    echo "Log File: $log_file"
    echo "Total Lines: $(wc -l < "$log_file")"
    echo "Error Count: $(grep -c "ERROR" "$log_file")"

    echo -e "\nTop 5 Errors:"
    grep "ERROR" "$log_file" | sort | uniq -c | sort -nr | head -5

    echo -e "\nCritical Events:"
    grep -n "CRITICAL" "$log_file"
} > "$report_file"

# Archive log
mkdir -p processed_logs
cp "$log_file" "processed_logs/$(basename "$log_file").$(date +%Y%m%d)"

echo "Report generated: $report_file"

Script Features 🔧

Analysis Capabilities
- Error counting
- Critical event detection
- Top error identification
- Line counting
Report Generation
- Timestamped reports
- Organized sections
- Statistical analysis
Log Management
- Automatic archiving
- Date-based organization
- Original file preservation

Key Takeaways 💡

Log analysis is crucial for troubleshooting
Pattern matching helps find issues
Reports should be well-organized
Archive management is important

Bash #DevOps #Monitoring #Linux #90DaysOfDevOps

This is Day 10 of my #90DaysOfDevOps journey. Keep analyzing and monitoring!

Day 9/90: Directory Backup with Rotation in Shell Scripting 🔄 #90DaysOfDevOps

Kanav Gathe — Wed, 23 Oct 2024 20:37:31 +0000

Day 9: Directory Backup with Rotation 🚀

Hello DevOps enthusiasts! 👋 Welcome to Day 9 of the #90DaysOfDevOps challenge. Today, we're building a backup system with rotation functionality.

Backup Script Solution 💻

#!/bin/bash

# Check if directory argument is provided
if [ $# -ne 1 ]; then
    echo "Usage: $0 <directory_path>"
    exit 1
fi

# Variables
source_dir="$1"
timestamp=$(date +%Y-%m-%d_%H-%M-%S)
backup_dir="${source_dir}/backup_${timestamp}"

# Check if source directory exists
if [ ! -d "$source_dir" ]; then
    echo "Error: Source directory does not exist"
    exit 1
fi

# Create backup
echo "Creating backup in $backup_dir"
mkdir -p "$backup_dir"
cp -r "${source_dir}/"* "$backup_dir" 2>/dev/null

# Implement rotation (keep only last 3 backups)
cd "$source_dir"
ls -d backup_* 2>/dev/null | sort | head -n -3 | xargs rm -rf 2>/dev/null

echo "Backup completed. Current backups:"
ls -d backup_* 2>/dev/null

Script Features 🔧

Input Validation
- Checks for correct usage
- Verifies directory existence
Backup Creation
- Timestamped backups
- Complete directory copying
- Error handling
Rotation Mechanism
- Maintains last 3 backups
- Automatically removes old backups
- Sorted by timestamp
Status Reports
- Clear error messages
- Completion confirmation
- Lists current backups

Usage Examples 📝

# Create backup
./backup_with_rotation.sh /home/user/documents

# Expected Output:
# Creating backup in /home/user/documents/backup_2024-10-24_14-30-00
# Backup completed. Current backups:
# backup_2024-10-24_12-00-00
# backup_2024-10-24_13-00-00
# backup_2024-10-24_14-30-00

Key Takeaways 💡

Automated backups ensure data safety
Rotation prevents disk space issues
Timestamps enable version tracking
Error handling is crucial

Bash #DevOps #Automation #Linux #90DaysOfDevOps

This is Day 9 of my #90DaysOfDevOps journey. Keep backing up and rotating!

Day 8/90: Shell Scripting Challenge - The Basics 📝 #90DaysOfDevOps

Kanav Gathe — Wed, 23 Oct 2024 20:35:18 +0000

Day 8: Shell Scripting Challenge - The Basics 🚀

Hello DevOps enthusiasts! 👋 Welcome to Day 8 of the #90DaysOfDevOps challenge. Today, we're learning basic shell scripting concepts through practical examples.

Task Solutions 💻

1. Comments in Shell Script

#!/bin/bash

# This is a shell script that demonstrates various basic concepts
# Author: DevOps Engineer
# Date: October 2024
# Version: 1.0

2. Echo Command Usage

#!/bin/bash

echo "Welcome to Shell Scripting!"
echo "This is Day 8 of #90DaysOfDevOps"

3. Variables Declaration

#!/bin/bash

# Declaring variables
name="DevOps Engineer"
course="Shell Scripting"
day=8
current_dir=$(pwd)

4. Using Variables

#!/bin/bash

# Take two numbers as input
read -p "Enter first number: " num1
read -p "Enter second number: " num2

# Calculate and show sum
sum=$((num1 + num2))
echo "The sum of $num1 and $num2 is: $sum"

5. Built-in Variables

#!/bin/bash

echo "Script Name: $0"
echo "Current User: $USER"
echo "Home Directory: $HOME"
echo "Present Working Directory: $PWD"
echo "Hostname: $HOSTNAME"

6. Using Wildcards

#!/bin/bash

# List all shell scripts
echo "Shell Scripts in current directory:"
ls *.sh

# List all text files
echo "Text files in current directory:"
ls *.txt

Combined Script Example 🔧

#!/bin/bash

# Comments explaining script purpose
# This script demonstrates basic shell scripting concepts

# Echo command
echo "Basic Shell Script Demo"

# Variables
name="DevOps Engineer"
day=8

# Using variables
echo "Hello, I am a $name"
echo "This is Day $day of #90DaysOfDevOps"

# Built-in variables
echo "Running from: $PWD"
echo "By user: $USER"

# Wildcards
echo "Script files:"
ls *.sh

Key Takeaways 💡

Comments make code readable and maintainable
Echo commands display output
Variables store and manage data
Built-in variables provide system information
Wildcards help in pattern matching

Bash #DevOps #Linux #Scripting #90DaysOfDevOps

This is Day 8 of my #90DaysOfDevOps journey. Keep scripting and automating!

Day 7/90: Package Manager and Systemctl in Linux 📦 #90DaysOfDevOps

Kanav Gathe — Wed, 23 Oct 2024 20:33:57 +0000

Day 7: Package Manager and Systemctl 🚀

Hello DevOps enthusiasts! 👋 Welcome to Day 7 of the #90DaysOfDevOps challenge. Today, we're exploring package management and service control using systemctl.

Task Solutions 💻

1. Docker Installation

# Ubuntu
sudo apt update
sudo apt install docker.io

# CentOS
sudo yum install docker

# Verify installation
docker --version
systemctl status docker

2. Jenkins Installation

# Ubuntu
wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -
sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
sudo apt update
sudo apt install jenkins

# Verify installation
jenkins --version
systemctl status jenkins

3. Service Management

# Check Docker status
sudo systemctl status docker

# Stop Jenkins
sudo systemctl stop jenkins

# Enable services
sudo systemctl enable docker
sudo systemctl disable jenkins

# Check logs
sudo journalctl -u docker
sudo journalctl -u jenkins

Package Management Commands 🔧

APT (Ubuntu/Debian)

sudo apt update          # Update package list
sudo apt install pkg     # Install package
sudo apt remove pkg      # Remove package
sudo apt upgrade         # Upgrade packages

YUM (CentOS/RHEL)

sudo yum update         # Update package list
sudo yum install pkg    # Install package
sudo yum remove pkg     # Remove package
sudo yum upgrade        # Upgrade packages

Systemctl Commands 🛠️

systemctl start service    # Start service
systemctl stop service     # Stop service
systemctl restart service  # Restart service
systemctl enable service   # Start on boot
systemctl disable service  # Don't start on boot
systemctl status service   # Check status

Key Takeaways 💡

Package managers simplify software installation
Systemctl manages system services
Service logs help in troubleshooting
Boot-time service management is crucial

Linux #DevOps #Docker #Jenkins #90DaysOfDevOps

This is Day 7 of my #90DaysOfDevOps journey. Keep learning and managing services!

Day 6/90: File Permissions and Access Control Lists in Linux 🔐 #90DaysOfDevOps

Kanav Gathe — Wed, 23 Oct 2024 20:27:22 +0000

Day 6: File Permissions and Access Control Lists 🚀

Hello DevOps enthusiasts! 👋 Welcome to Day 6 of the #90DaysOfDevOps challenge. Today, we're exploring file permissions and Access Control Lists (ACL) in Linux.

Task Solutions 💻

1. Basic File Permissions

# Create and check file
touch test_file.txt
ls -ltr test_file.txt

# Change permissions (owner only)
chmod 700 test_file.txt
# OR
chmod u+rwx,go-rwx test_file.txt

# Verify changes
ls -ltr test_file.txt

2. Permission Management Script

#!/bin/bash

# Change permissions for multiple files
change_permissions() {
    for file in "$@"
    do
        chmod 644 "$file"
        echo "Changed permissions for $file"
    done
}

3. ACL Implementation

# Create test directory
mkdir acl_test
cd acl_test

# Set ACL for user
setfacl -m u:user1:rx file1.txt

# Set ACL for group
setfacl -m g:group1:rw file1.txt

# View ACL
getfacl file1.txt

4. ACL Permission Script

#!/bin/bash

set_acl_permissions() {
    local file=$1
    local user=$2
    setfacl -m u:$user:rw "$file"
    echo "Set ACL for $user on $file"
}

5. Special Permissions

# Sticky Bit
chmod +t /shared_directory

# SUID
chmod u+s /usr/bin/script

# SGID
chmod g+s /shared_directory

6. Permission Backup

#!/bin/bash

# Backup permissions
getfacl -R /path/to/directory > permissions.acl

# Restore permissions
setfacl --restore=permissions.acl

Permission Types Explained 📝

Basic Permissions
- Read (r): 4
- Write (w): 2
- Execute (x): 1
Special Permissions
- SUID (4000)
- SGID (2000)
- Sticky Bit (1000)
ACL Features
- User-specific permissions
- Group-specific permissions
- Default permissions
- Inherited permissions

Key Takeaways 💡

File permissions are crucial for security
ACLs provide granular access control
Special permissions serve specific purposes
Regular permission backups are important

Linux #DevOps #Security #90DaysOfDevOps

This is Day 6 of my #90DaysOfDevOps journey. Keep securing and learning!

Day 5/90: Advanced Shell Scripting for DevOps Engineers 🛠️ #90DaysOfDevOps

Kanav Gathe — Wed, 23 Oct 2024 20:21:33 +0000

Day 5: Advanced Shell Scripting for DevOps Engineers 🚀

Hello DevOps enthusiasts! 👋 Welcome to Day 5 of the #90DaysOfDevOps challenge. Today, we're diving into advanced shell scripting with directory creation, backup automation, and user management.

Task Solutions 💻

1. Directory Creation Script

#!/bin/bash

# Function to create multiple directories
create_directories() {
    local dirname=$1
    local start=$2
    local end=$3

    for ((i=start; i<=end; i++)); do
        mkdir -p "${dirname}${i}"
    done
    echo "Created directories from ${dirname}${start} to ${dirname}${end}"
}

# Example usage:
# ./createDirectories.sh day 1 90
# Creates day1 through day90

2. Backup Script Implementation

#!/bin/bash

# Function to create backup
backup_workspace() {
    local source_dir=$1
    local backup_dir="backup_$(date +%Y%m%d_%H%M%S)"

    mkdir -p "$backup_dir"
    cp -r "$source_dir"/* "$backup_dir"
    echo "Backup created in: $backup_dir"
}

# Example usage:
# ./backup.sh /path/to/source

3. Crontab for Automated Backup

# Add daily backup at midnight
0 0 * * * /path/to/backup_script.sh

# Check existing crontab
crontab -l

# Add new cron job
(crontab -l 2>/dev/null; echo "0 0 * * * /path/to/backup_script.sh") | crontab -

4. User Management

#!/bin/bash

# Create users
sudo useradd -m user1
sudo useradd -m user2

# Display created users
grep "^user[12]" /etc/passwd

Script Features 🔧

Directory Creation
- Dynamic directory naming
- Range-based creation
- Error handling
Backup System
- Timestamp-based backups
- Full directory copying
- Automatic organization
Automation
- Crontab integration
- Scheduled execution
- Regular backups
User Management
- User creation
- System integration
- Verification steps

Key Takeaways 💡

Shell scripts can automate complex tasks
Proper timestamp usage is crucial for backups
Crontab enables scheduled automation
User management requires proper permissions

Bash #DevOps #Automation #Linux #90DaysOfDevOps

This is Day 5 of my #90DaysOfDevOps journey. Keep automating and improving!