Best DevOps Training Institute in Greater Noida 2026

# GitHub Actions — build, test, and deploy a container
# The exact shape of the first DevOps project interviewers ask about.

name: deploy

on:
  push:
    branches: [main]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Log in to registry
        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Build and push image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ghcr.io/${{ github.repository }}:${{ github.sha }}

      - name: Deploy to server
        uses: appleboy/ssh-action@v1
        with:
          host: ${{ secrets.SSH_HOST }}
          username: ${{ secrets.SSH_USER }}
          key: ${{ secrets.SSH_KEY }}
          script: |
            docker pull ghcr.io/${{ github.repository }}:${{ github.sha }}
            docker stop app || true
            docker rm app || true
            docker run -d --name app -p 80:3000 \
              ghcr.io/${{ github.repository }}:${{ github.sha }}

# What this proves in an interview:
# - You understand a full pipeline: build → tag → deploy
# - You use secrets correctly, not hard-coded credentials
# - You tag images by commit SHA for traceability
# - You handle container lifecycle (stop → remove → run)

# This is the exact pipeline pattern most junior DevOps
# interviews probe. Being able to explain each step
# matters more than the tool name.

# Terraform — a small but complete AWS stack
# The kind of IaC project that separates "learned tools"
# from "can actually build infrastructure".

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

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  tags = { Name = "demo-vpc" }
}

resource "aws_subnet" "public" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  map_public_ip_on_launch = true
  tags = { Name = "demo-public-subnet" }
}

resource "aws_security_group" "web" {
  vpc_id = aws_vpc.main.id

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

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = [var.my_ip]
  }

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

resource "aws_instance" "app" {
  ami                    = "ami-0abcd1234efgh5678"
  instance_type          = "t2.micro"
  subnet_id              = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web.id]

  tags = { Name = "demo-app-server" }
}

# What this proves in an interview:
# - You can express infrastructure as code, not clicks
# - You reason about VPC + subnet + SG together
# - You avoid hard-coded sensitive values (use var.my_ip)
# - You can explain state, plan, apply, destroy

# The project's value is the README that explains WHY
# each resource exists, not just the code.

# Kubernetes — a deployment + service + ingress
# The minimum junior K8s competence interviewers expect.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: demo-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: demo-app
  template:
    metadata:
      labels:
        app: demo-app
    spec:
      containers:
        - name: app
          image: ghcr.io/your-org/demo-app:latest
          ports:
            - containerPort: 3000
          env:
            - name: NODE_ENV
              value: "production"
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
            limits:
              cpu: "500m"
              memory: "512Mi"
          readinessProbe:
            httpGet:
              path: /healthz
              port: 3000
            initialDelaySeconds: 5

---
apiVersion: v1
kind: Service
metadata:
  name: demo-app
spec:
  selector:
    app: demo-app
  ports:
    - port: 80
      targetPort: 3000
  type: ClusterIP

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: demo-app
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
    - host: demo.local
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: demo-app
                port:
                  number: 80

# What this proves in an interview:
# - You understand Deployment → Pod → Service → Ingress
# - You set resource requests and limits (not defaults)
# - You configure readiness probes for rolling updates
# - You know how traffic reaches a pod from outside

# If you can explain each block and modify it for a
# second app, you are junior-K8s interview-ready.