DevOps for Java Developers¶

pwd                        # Print Working Directory: shows exactly where you are right now
ls -la                     # List all files (including hidden ones) with details like permissions and size
cd /var/log                # Change Directory: moves you into the /var/log folder
mkdir -p app/src/main      # Make Directory: creates nested folders all at once (thanks to -p)
cp file.txt backup/        # Copy: duplicates file.txt into the backup folder
mv old.txt new.txt         # Move: renames old.txt to new.txt (or moves it to another folder)
rm -rf build/              # Remove: recursively (-r) and forcefully (-f) deletes the build folder. CAREFUL!
find / -name "*.log" -mtime -1   # Find: searches the whole system (/) for .log files modified in the last 1 day (-mtime -1)

cat application.yml        # Concatenate: prints the entire content of the file to the screen
head -n 20 server.log      # Head: prints only the first 20 lines of the file
tail -f server.log         # Tail: follows the file in real-time, printing new lines as they are added (crucial for live debugging)
grep -r "ERROR" /var/log/  # Global Regular Expression Print: searches recursively (-r) for the word "ERROR" in the /var/log/ folder
grep -i "exception" app.log | wc -l   # Finds "exception" case-insensitively (-i) and pipes (|) the result to Word Count (wc) to count the lines (-l)

ps aux                     # Process Status: lists all running processes for all users
ps aux | grep java         # Finds processes, but filters only the ones containing the word "java"
top                        # Shows a real-time, dynamic view of running processes and CPU/RAM usage
htop                       # A better, colorful version of top (usually needs to be installed first)
kill -9 <PID>              # Sends signal 9 (SIGKILL) to forcefully terminate a process by its Process ID (PID)
nohup java -jar app.jar &  # No Hangup (nohup) keeps the app running after you log out. '&' puts it in the background

chmod 755 deploy.sh        # Change Mode: sets permissions to rwxr-xr-x (owner: read/write/execute, others: read/execute)
chmod +x script.sh         # Makes the file executable (+x)
chown appuser:appgroup /opt/myapp   # Change Owner: assigns the file to 'appuser' and group 'appgroup'

curl -X GET http://localhost:8080/api/health    # Client URL (curl): makes an HTTP GET request to test an endpoint
curl -X POST -H "Content-Type: application/json" -d '{"name":"test"}' http://localhost:8080/api/users # Makes a POST request with JSON data
netstat -tlnp              # Network Statistics: shows listening TCP ports (-t), listening status (-l), numeric addresses (-n), and process IDs (-p)
ss -tlnp                   # Socket Statistics: a faster, modern alternative to netstat
ping google.com            # Sends ICMP packets to test if a server is reachable and how fast it responds
ssh user@server            # Secure Shell: logs you into a remote server securely
scp app.jar user@server:/opt/app/   # Secure Copy: securely transfers a file from your machine to a remote server

#!/bin/bash
# The line above tells the OS to use the 'bash' shell to run this script

APP_NAME="myapp"
JAR_FILE="target/${APP_NAME}.jar"
LOG_FILE="/var/log/${APP_NAME}.log"

# 'echo' prints text to the screen (like System.out.println in Java)
echo "Building application..."

# 'mvn' runs Maven to compile and package the Java code into a JAR file
mvn clean package -DskipTests

# '$?' holds the exit code of the last command. 0 means success.
# '-ne' means "not equal". So this checks if Maven failed.
if [ $? -ne 0 ]; then
    echo "Build failed!"
    exit 1   # Stop the script with an error code (1)
fi

echo "Stopping existing instance..."
# 'pkill' finds running processes matching a name and kills them
# '2>/dev/null' hides error messages just in case the process wasn't running
pkill -f "${APP_NAME}.jar" 2>/dev/null

# 'sleep 2' pauses the script for 2 seconds to let the process fully stop
sleep 2

echo "Starting application..."
# 'nohup' prevents the app from stopping when you close your terminal
# '> "${LOG_FILE}" 2>&1' redirects all console output (logs and errors) into the log file
# '&' at the very end runs the process in the background
nohup java -jar "${JAR_FILE}" --spring.profiles.active=prod > "${LOG_FILE}" 2>&1 &

# '$!' gets the Process ID (PID) of the background job we just started
echo "Application started. PID: $!"
echo "Logs: tail -f ${LOG_FILE}"

# Daily workflow
git checkout -b feature/user-auth develop    # Create feature branch
git add .                                      # Stage changes
git commit -m "feat: add user authentication"  # Commit
git push origin feature/user-auth              # Push to remote

# Keeping up to date
git fetch origin
git rebase origin/develop                      # Rebase onto latest develop

# Pull request workflow
# 1. Push feature branch
# 2. Create PR on GitHub
# 3. Code review
# 4. Squash and merge

# Useful commands
git log --oneline -10                          # Recent commits
git stash                                      # Temporarily save changes
git stash pop                                  # Restore stashed changes
git diff                                       # View unstaged changes
git blame filename.java                        # Who changed what line

# Reads the Dockerfile in the current directory ('.') and builds an image named 'myapp' with tag '1.0'
docker build -t myapp:1.0 .

# Runs the image as a container. '-p 8080:8080' maps port 8080 on your computer to 8080 in the container
docker run -p 8080:8080 myapp:1.0

# Starts all services defined in 'docker-compose.yml'. '-d' means detached (run in background)
docker compose up -d

# Stops and removes all containers, networks, and volumes created by 'up'
docker compose down

# Follows the live console output ('-f') for the service named 'app'
docker compose logs -f app

# Lists all currently running containers and their IDs
docker ps

# Opens an interactive terminal ('-it') inside the running container using the shell ('/bin/sh')
docker exec -it <container> /bin/sh

# Lists all downloaded and built Docker images on your machine
docker images

# Cleans up and deletes all stopped containers, unused networks, and dangling images
docker system prune -a