Scale deployment

Update deployment

Check rollout status

Rollback deployment

Port forwarding for testing

Create namespace

Switch context

Automation Tools and Practices

Automation is the backbone of DevOps, reducing manual effort, minimizing errors, and ensuring consistency across environments.

Infrastructure as Code (IaC)

Infrastructure as Code treats infrastructure configuration as software code, making it version-controlled, testable, and repeatable.

#### Terraform Example

Create main.tf:

`hcl

Configure AWS Provider

provider "aws" { region = var.aws_region }

Variables

variable "environment" { description = "Environment name" type = string default = "production" }

VPC

tags = { Name = "${var.environment}-vpc" Environment = var.environment } }

Internet Gateway

tags = { Name = "${var.environment}-igw" Environment = var.environment } }

Subnets

map_public_ip_on_launch = true

tags = { Name = "${var.environment}-public-${count.index + 1}" Environment = var.environment } }

Security Group

ingress { from_port = 80 to_port = 80 protocol = "tcp" cidr_blocks = ["0.0.0.0/0"] }

ingress { from_port = 443 to_port = 443 protocol = "tcp" cidr_blocks = ["0.0.0.0/0"] }

egress { from_port = 0 to_port = 0 protocol = "-1" cidr_blocks = ["0.0.0.0/0"] }

tags = { Name = "${var.environment}-web-sg" Environment = var.environment } }

Launch Template

vpc_security_group_ids = [aws_security_group.web.id]

user_data = base64encode(templatefile("${path.module}/user_data.sh", { environment = var.environment }))

tag_specifications { resource_type = "instance" tags = { Name = "${var.environment}-app" Environment = var.environment } } }

Auto Scaling Group

min_size = 2 max_size = 10 desired_capacity = 3

launch_template { id = aws_launch_template.app.id version = "$Latest" }

tag { key = "Name" value = "${var.environment}-app-asg" propagate_at_launch = false } }

Application Load Balancer

enable_deletion_protection = false

tags = { Name = "${var.environment}-app-alb" Environment = var.environment } }

Target Group

health_check { enabled = true healthy_threshold = 2 interval = 30 matcher = "200" path = "/health" port = "traffic-port" protocol = "HTTP" timeout = 5 unhealthy_threshold = 2 }

tags = { Name = "${var.environment}-app-tg" Environment = var.environment } }

Load Balancer Listener

default_action { type = "forward" target_group_arn = aws_lb_target_group.app.arn } }

Data Sources

data "aws_ami" "amazon_linux" { most_recent = true owners = ["amazon"]

filter { name = "name" values = ["amzn2-ami-hvm-*-x86_64-gp2"] } }

Outputs

output "vpc_id" { description = "VPC ID" value = aws_vpc.main.id } `

#### Ansible Playbook Example

Create playbook.yml:

`yaml --- - name: Deploy Web Application hosts: webservers become: yes vars: app_name: myapp app_version: "#" app_port: 3000 tasks: - name: Update system packages yum: name: "*" state: latest - name: Install Docker yum: name: docker state: present - name: Start Docker service systemd: name: docker state: started enabled: yes - name: Add user to docker group user: name: "#" groups: docker append: yes - name: Install Docker Compose pip: name: docker-compose state: present - name: Create application directory file: path: "/opt/#" state: directory owner: "#" group: "#" mode: '0755' - name: Copy docker-compose file template: src: docker-compose.yml.j2 dest: "/opt/#/docker-compose.yml" owner: "#" group: "#" mode: '0644' notify: restart application - name: Copy application configuration template: src: app.conf.j2 dest: "/opt/#/app.conf" owner: "#" group: "#" mode: '0644' notify: restart application - name: Pull Docker images docker_image: name: "myregistry.com/#:#" source: pull - name: Start application docker_compose: project_src: "/opt/#" state: present - name: Configure firewall firewalld: port: "#/tcp" permanent: yes state: enabled immediate: yes handlers: - name: restart application docker_compose: project_src: "/opt/#" restarted: yes `

Monitoring and Alerting

#### Prometheus Configuration

Create prometheus.yml:

`yaml global: scrape_interval: 15s evaluation_interval: 15s

rule_files: - "alert_rules.yml"

alerting: alertmanagers: - static_configs: - targets: - alertmanager:9093

scrape_configs: - job_name: 'prometheus' static_configs: - targets: ['localhost:9090']

- job_name: 'node-exporter' static_configs: - targets: ['node-exporter:9100']

- job_name: 'myapp' static_configs: - targets: ['myapp:3000'] metrics_path: '/metrics' scrape_interval: 30s

- job_name: 'kubernetes-pods' kubernetes_sd_configs: - role: pod relabel_configs: - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape] action: keep regex: true - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path] action: replace target_label: __metrics_path__ regex: (.+) `

#### Alert Rules

Create alert_rules.yml:

`yaml groups: - name: application_alerts rules: - alert: HighErrorRate expr: rate(http_requests_total{status=~"5.."}[5m]) > 0.1 for: 5m labels: severity: critical annotations: summary: "High error rate detected" description: "Error rate is # errors per second"

- alert: HighMemoryUsage expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes > 0.8 for: 5m labels: severity: warning annotations: summary: "High memory usage" description: "Memory usage is above 80%"

- alert: ServiceDown expr: up == 0 for: 1m labels: severity: critical annotations: summary: "Service is down" description: "# service is down" `

Building Your First CI/CD Pipeline

Let's create a complete CI/CD pipeline for a Node.js application using GitHub Actions.

Project Structure

` my-web-app/ ├── .github/ │ └── workflows/ │ └── ci-cd.yml ├── src/ │ ├── app.js │ ├── routes/ │ └── middleware/ ├── tests/ │ ├── unit/ │ └── integration/ ├── docker/ │ ├── Dockerfile │ └── docker-compose.yml ├── k8s/ │ ├── deployment.yml │ ├── service.yml │ └── ingress.yml ├── package.json ├── .dockerignore ├── .gitignore └── README.md `

Complete CI/CD Pipeline

Create .github/workflows/ci-cd.yml:

`yaml name: CI/CD Pipeline

on: push: branches: [ main, develop ] pull_request: branches: [ main ]

env: REGISTRY: ghcr.io IMAGE_NAME: $#

jobs: # Continuous Integration test: name: Test and Build runs-on: ubuntu-latest strategy: matrix: node-version: [16.x, 18.x] steps: - name: Checkout code uses: actions/checkout@v3 - name: Setup Node.js $# uses: actions/setup-node@v3 with: node-version: $# cache: 'npm' - name: Install dependencies run: npm ci - name: Run linting run: npm run lint - name: Run unit tests run: npm run test:unit - name: Run integration tests run: npm run test:integration - name: Generate test coverage run: npm run test:coverage - name: Upload coverage to Codecov uses: codecov/codecov-action@v3 with: file: ./coverage/lcov.info - name: Build application run: npm run build - name: Archive build artifacts uses: actions/upload-artifact@v3 with: name: build-files path: dist/

# Security Scanning security: name: Security Scan runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v3 - name: Run npm audit run: npm audit --audit-level moderate - name: Run Snyk to check for vulnerabilities uses: snyk/actions/node@master env: SNYK_TOKEN: $#

# Docker Build and Push build-and-push: name: Build and Push Docker Image runs-on: ubuntu-latest needs: [test, security] if: github.ref == 'refs/heads/main' permissions: contents: read packages: write steps: - name: Checkout code uses: actions/checkout@v3 - name: Log in to Container Registry uses: docker/login-action@v2 with: registry: $# username: $# password: $# - name: Extract metadata id: meta uses: docker/metadata-action@v4 with: images: $#/$# tags: | type=ref,event=branch type=sha,prefix=#- type=raw,value=latest,enable=# - name: Build and push Docker image uses: docker/build-push-action@v4 with: context: . file: ./docker/Dockerfile push: true tags: $# labels: $#

# Deploy to Staging deploy-staging: name: Deploy to Staging runs-on: ubuntu-latest needs: build-and-push if: github.ref == 'refs/heads/develop' environment: name: staging url: https://staging.myapp.com steps: - name: Checkout code uses: actions/checkout@v3 - name: Setup kubectl uses: azure/setup-kubectl@v3 with: version: 'v1.25.0' - name: Configure AWS credentials uses: aws-actions/configure-aws-credentials@v2 with: aws-access-key-id: $# aws-secret-access-key: $# aws-region: us-west-2 - name: Update kube config run: aws eks update-kubeconfig --name staging-cluster - name: Deploy to staging run: | sed -i 's|IMAGE_TAG|$#|g' k8s/deployment.yml kubectl apply -f k8s/ -n staging kubectl rollout status deployment/myapp -n staging

# Deploy to Production deploy-production: name: Deploy to Production runs-on: ubuntu-latest needs: build-and-push if: github.ref == 'refs/heads/main' environment: name: production url: https://myapp.com steps: - name: Checkout code uses: actions/checkout@v3 - name: Setup kubectl uses: azure/setup-kubectl@v3 with: version: 'v1.25.0' - name: Configure AWS credentials uses: aws-actions/configure-aws-credentials@v2 with: aws-access-key-id: $# aws-secret-access-key: $# aws-region: us-west-2 - name: Update kube config run: aws eks update-kubeconfig --name production-cluster - name: Deploy to production run: | sed -i 's|IMAGE_TAG|$#|g' k8s/deployment.yml kubectl apply -f k8s/ -n production kubectl rollout status deployment/myapp -n production - name: Run smoke tests run: | curl -f https://myapp.com/health || exit 1 curl -f https://myapp.com/api/status || exit 1

# Notify notify: name: Notify Team runs-on: ubuntu-latest needs: [deploy-production] if: always() steps: - name: Notify Slack uses: 8398a7/action-slack@v3 with: status: $# channel: '#deployments' webhook_url: $# if: always() `

Application Code Example

Create src/app.js:

`javascript const express = require('express'); const prometheus = require('prom-client'); const app = express(); const port = process.env.PORT || 3000;

// Prometheus metrics const collectDefaultMetrics = prometheus.collectDefaultMetrics; collectDefaultMetrics({ timeout: 5000 });

const httpRequestDuration = new prometheus.Histogram({ name: 'http_request_duration_seconds', help: 'Duration of HTTP requests in seconds', labelNames: ['method', 'route', 'status_code'], buckets: [0.1, 0.3, 0.5, 0.7, 1, 3, 5, 7, 10] });

const httpRequestTotal = new prometheus.Counter({ name: 'http_requests_total', help: 'Total number of HTTP requests', labelNames: ['method', 'route', 'status_code'] });

// Middleware app.use(express.json());

app.use((req, res, next) => { const start = Date.now(); res.on('finish', () => { const duration = (Date.now() - start) / 1000; const labels = { method: req.method, route: req.route?.path || req.path, status_code: res.statusCode }; httpRequestDuration.observe(labels, duration); httpRequestTotal.inc(labels); }); next(); });

// Routes app.get('/health', (req, res) => { res.status(200).json({ status: 'healthy', timestamp: new Date().toISOString(), uptime: process.uptime() }); });

app.get('/ready', (req, res) => { // Add readiness checks here (database, external services, etc.) res.status(200).json({ status: 'ready', timestamp: new Date().toISOString() }); });

app.get('/metrics', (req, res) => { res.set('Content-Type', prometheus.register.contentType); res.end(prometheus.register.metrics()); });

app.get('/', (req, res) => { res.json({ message: 'Hello, DevOps World!', version: process.env.APP_VERSION || '1.0.0', environment: process.env.NODE_ENV || 'development' }); });

app.get('/api/status', (req, res) => { res.json({ status: 'running', timestamp: new Date().toISOString(), memory: process.memoryUsage(), uptime: process.uptime() }); });

// Error handling app.use((err, req, res, next) => { console.error(err.stack); res.status(500).json({ error: 'Something went wrong!', timestamp: new Date().toISOString() }); });

// 404 handler app.use((req, res) => { res.status(404).json({ error: 'Not found', path: req.path, timestamp: new Date().toISOString() }); });

// Graceful shutdown process.on('SIGTERM', () => { console.log('SIGTERM received, shutting down gracefully'); server.close(() => { console.log('Process terminated'); }); });

const server = app.listen(port, () => { console.log(Server running on port ${port}); });

module.exports = app; `

Best Practices and Common Pitfalls

DevOps Best Practices

#### 1. Start Small and Iterate

` Traditional Approach: [Planning] → [Big Bang Implementation] → [Hope for Success]

DevOps Approach: [Small Change] → [Test] → [Learn] → [Iterate] → [Improve] `

#### 2. Implement Proper Monitoring

` Monitoring Pyramid:

Application Metrics (Business KPIs) ↑ Infrastructure Metrics (CPU, Memory, Disk) ↑ Log Aggregation (Centralized Logging) ↑ Health Checks (Basic Availability) `

#### 3. Security Integration (DevSecOps)

` Traditional Security: [Develop] → [Test] → [Security Review] → [Deploy]

DevSecOps: [Develop] → [Security Scan] → [Test] → [Security Test] → [Deploy] → [Monitor] `

Common Pitfalls and Solutions

#### 1. Inadequate Testing

Problem: Rushing to automate without proper testing Solution: Implement comprehensive testing strategy

`yaml

Testing Strategy

#### 2. Ignoring Rollback Strategies

Problem: No plan for when deployments go wrong Solution: Always have a rollback plan

`bash

Kubernetes rollback example

Blue-green deployment rollback

Simply switch traffic back to previous version

Database migration rollback

Always write reversible migrations

#### 3. Poor Secret Management

Problem: Hardcoding secrets in code or configs Solution: Use proper secret management

`yaml

Kubernetes secrets