Shell Scripting for DevOps

# CHAPTER 18

Shell Scripting for DevOps #

1. Introduction #

2. Learning Objectives #

• Understand the foundational role of shell scripting within a modern CI/CD pipeline.

• Write an automated Git repository synchronization workflow (git pull / git reset).

• Write a script to autonomously build, stop, and launch Docker containers.

• Safely manage sensitive cryptographic environment variables (secrets) using .env files.

• Architect an automated, zero-downtime deployment script.

3. The Shell in the CI/CD Pipeline #

1. 1. Build: Compiles the software (e.g., npm run build).

1. 2. Test: Runs automated test suites. If the test returns a non-zero exit code ($?), the script uses set -e to violently abort the pipeline.

1. 3. Deploy: Pushes the finalized code or Docker container to the production cloud server.

4. Git Deployment Automation #

#!/bin/sh
set -e

APP_DIR="/var/www/my_startup"
REPO_BRANCH="main"

echo "=== INITIATING GITHUB DEPLOYMENT ==="

# 1. Navigate to the application directory
cd "$APP_DIR" || { echo "Fatal: Directory missing"; exit 1; }

# 2. Pull the latest code securely
echo "Pulling latest code from branch: $REPO_BRANCH..."
git fetch origin

# Using 'reset --hard' ensures the server exactly matches GitHub, 
# obliterating any manual changes someone made on the server!
git reset --hard "origin/$REPO_BRANCH"

# 3. Apply changes (e.g., restart the web server to load the new code)
echo "Restarting application daemon..."
sudo systemctl restart my_startup_service

echo "=== DEPLOYMENT SUCCESSFUL ==="

*(This script completely replaces the archaic, highly insecure practice of manually dragging and dropping files via FTP).*

5. Docker Container Automation #

#!/bin/sh
set -e

IMAGE_NAME="company_api"
CONTAINER_NAME="production_api"
PORT="8080"

echo "1. Compiling new Docker image..."
docker build -t "$IMAGE_NAME:latest" .

echo "2. Halting existing legacy container..."
# We explicitly bypass set -e using '|| true' so the script doesn't crash 
# if the container doesn't exist yet!
docker stop "$CONTAINER_NAME" 2>/dev/null || true
docker rm "$CONTAINER_NAME" 2>/dev/null || true

echo "3. Launching new container..."
docker run -d --name "$CONTAINER_NAME" -p "$PORT:80" "$IMAGE_NAME:latest"

echo "Container deployed. Application actively listening on port $PORT."

6. Managing Secrets (.env files) #

The .env file (stored securely on the server):

DB_USER="admin"
DB_PASS="SuperSecret123!"

The Shell Script:

#!/bin/sh

# 'source' (or '.') reads the file and injects its variables directly into the script
. /secure/path/.env

# The variables are now safely loaded into RAM!
echo "Connecting to database as $DB_USER..."
# Execute database connection utilizing $DB_PASS...

7. Diagrams/Visual Suggestions #

• Arrow 1: To a Docker icon (Building the container image).

• Arrow 2: To an npm icon (Running the test suite).

• Arrow 3: To an AWS Cloud icon (Deploying the finalized container).

8. Best Practices #

• Immutable Infrastructure: When scripting deployments, do not write code that attempts to surgically fix a broken server (e.g., deleting bad files one by one). In modern DevOps, if a server is broken, you write a script to completely destroy the entire server and instantly deploy a brand-new, fresh clone. Treat your servers like cattle, not pets.

9. Common Mistakes #

• Running git clone instead of git fetch: Beginners often write deployment scripts that attempt to git clone the repository every single time they deploy. This fails catastrophically on the second deployment because the target directory already exists. You must clone the repository manually *once*, and then architect your script to use git fetch and git reset to rapidly synchronize the existing directory.

10. Mini Project: Build a "Deploy" Wrapper Tool #

1. 1. nano deploy_local.sh

1. 2. Write the code:

#!/bin/sh
set -e

# Validation
if [ -z "$1" ]; then
    echo "Usage: ./deploy_local.sh [branch_name]"
    exit 1
fi

BRANCH="$1"
APP_DIR="/opt/dev_environment"

echo "[*] Synchronizing code with branch: $BRANCH"
cd "$APP_DIR"
git checkout "$BRANCH"
git pull origin "$BRANCH"

echo "[*] Tearing down legacy containers..."
docker-compose down

echo "[*] Rebuilding architecture..."
docker-compose up -d --build

echo "[SUCCESS] Local environment is live and tracking branch '$BRANCH'."

1. 3. Developers can now simply type ./deploy_local.sh feature-login to instantly spin up an entire testing infrastructure.

11. Practice Exercises #

1. 1. Explain the philosophical paradigm shift from traditional system administration (manually logging in to configure an Apache web server) to modern DevOps CI/CD methodologies (Dockerizing an application via a Shell script).

1. 2. Detail the critical cybersecurity vulnerability of hardcoding a database password directly into a deploy.sh script, and walk through the architectural solution utilizing a .env file.

12. MCQs with Answers #

13. Interview Questions #

• Q: A developer merges new code into the GitHub main branch. Walk me through the high-level conceptual steps of how a CI/CD server utilizes a shell script to transform that raw code into a live Docker container actively running on a production web server.

• Q: You are auditing a deployment script and notice the command git pull origin main. Explain why a professional DevOps engineer would replace this with git fetch followed by git reset --hard origin/main in a fully automated, headless environment.

• Q: Explain the necessity of the set -e directive within the context of a Continuous Integration testing script. If a Python unit test fails, how does the Shell interpreter communicate that exact failure back up to the Jenkins CI/CD graphical dashboard?

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #