# Dockerfile — a small Node.js app
FROM node:20-slim

WORKDIR /app

# Install dependencies first for better caching
COPY package*.json ./
RUN npm ci --omit=dev

# Copy the app code
COPY . .

EXPOSE 3000

CMD ["node", "server.js"]

# Build and run:
#   docker build -t my-app:1.0 .
#   docker run -p 3000:3000 my-app:1.0

# Two things interviewers look for in a Dockerfile:
# 1. Layer-caching order (package files first)
# 2. Small, secure base images (slim, not "latest")

# GitHub Actions — build, test, and deploy
# .github/workflows/deploy.yml

name: Deploy

on:
  push:
    branches: [main]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: "20"

      - name: Install deps
        run: npm ci

      - name: Run tests
        run: npm test

      - name: Build image
        run: docker build -t my-app:${{ github.sha }} .

      - name: Push to registry
        env:
          REGISTRY_TOKEN: ${{ secrets.REGISTRY_TOKEN }}
        run: |
          echo "$REGISTRY_TOKEN" | docker login myregistry.io \
            -u ${{ secrets.REGISTRY_USER }} --password-stdin
          docker tag my-app:${{ github.sha }} \
            myregistry.io/my-app:${{ github.sha }}
          docker push myregistry.io/my-app:${{ github.sha }}

      - name: Deploy
        run: |
          echo "Deploying ${{ github.sha }} to staging"
          # e.g., kubectl set image deploy/my-app \
          #   app=myregistry.io/my-app:${{ github.sha }}

# Terraform — an S3 + CloudFront setup
# (a common "first IaC project" for DevOps beginners)

provider "aws" {
  region = "ap-south-1"
}

resource "aws_s3_bucket" "site" {
  bucket = "my-devops-portfolio-site"
}

resource "aws_s3_bucket_versioning" "v" {
  bucket = aws_s3_bucket.site.id
  versioning_configuration {
    status = "Enabled"
  }
}

resource "aws_cloudfront_distribution" "cdn" {
  enabled = true

  origin {
    domain_name = aws_s3_bucket.site.bucket_domain_name
    origin_id   = "s3-site"
  }

  default_cache_behavior {
    target_origin_id       = "s3-site"
    viewer_protocol_policy = "redirect-to-https"
    allowed_methods        = ["GET", "HEAD"]
    cached_methods         = ["GET", "HEAD"]
    forwarded_values {
      query_string = false
      cookies { forward = "none" }
    }
  }

  restrictions {
    geo_restriction { restriction_type = "none" }
  }

  viewer_certificate {
    cloudfront_default_certificate = true
  }
}

# Run:
#   terraform init
#   terraform plan
#   terraform apply
# Then destroy when done — IaC is reproducible by design.

Project 1 — Deploy a website with Docker + CI/CD
(Start here — 1-2 weeks)

1. Build a small static site or Node app
2. Write a Dockerfile
3. Push to GitHub
4. Add a GitHub Actions workflow:
   - Build image
   - Push to a registry
   - Deploy to a cloud VM or Kubernetes
5. Add a README with architecture diagram

Why it works:
- Covers Docker, Git, CI/CD, and cloud
- One URL you can share with recruiters
- Easy to explain end-to-end

Project 2 — Infrastructure as Code with Terraform
(2-3 weeks)

1. Provision an S3 bucket + CloudFront site
2. Store state in a remote backend (S3 + DynamoDB)
3. Use variables and modules
4. Add a README explaining the layout
5. Run `terraform destroy` at the end

Bonus: add a small Kubernetes cluster
       (EKS or k3s on a VM)

Why it works:
- Shows real IaC discipline
- Reproducible and auditable
- Covers the most-hired DevOps skill
  after Docker

Weekly study plan (15–20 hours):
Mon 2h — Learn (video / docs)
Tue 2h — Practice in the terminal
Wed 2h — Learn
Thu 2h — Practice
Fri 1.5h — Review + notes
Sat 4h — Project work
Sun 2.5h — Deploy / document / rest

Consistency beats intensity.
Track hours to keep momentum.

Job search plan (Month 9):
Week 1: Resume + LinkedIn for DevOps roles
Week 2: Polish GitHub + project READMEs
Week 3: Apply to 10 roles per week
Week 4: 2 mock interviews
Week 5: Follow up + iterate
Week 6: Engage in DevOps communities

Aim for 8–12 quality applications per week.
Tailor the cover note to each role.