$ ls -la

$ cd /home && pwd

$ grep 'error' app.log

$ find . -name '*.txt'

$ chmod 755 myscript.sh

$ chmod 644 config.txt

$ chown user:group myfile.txt

$ ls -l myfile.txt

$ ls /var/log

$ cd /etc && ls

$ ls /home

$ df -h

$ ps aux

$ top

$ kill 1234

$ jobs

$ #!/bin/bash
echo "Deployment started"

$ APP_NAME="myapp"
echo "Deploying $APP_NAME"

$ if [ -f app.log ]; then
  echo "Log file found"
fi

$ for server in web1 web2 web3; do
  echo "Checking $server"
done

$ systemctl status nginx

$ systemctl restart docker

$ systemctl enable nginx

$ systemctl logs nginx

$ tail -f /var/log/nginx/error.log

$ grep "ERROR" /var/log/app.log

$ journalctl -u docker

$ tail -100 /var/log/syslog

$ crontab -l

$ crontab -e

$ 0 2 * * * /backup/backup.sh

$ */5 * * * * /health/check.sh

$ sudo adduser newuser

$ sudo passwd username

$ sudo ufw status

$ who

$ docker ps

$ docker images

$ docker logs myapp

$ docker exec -it myapp bash

$ htop

$ free -h

$ uptime

$ df -h

$ ping -c 4 8.8.8.8

$ curl -I https://example.com

$ ss -tulpen

$ dig A example.com +short

$ lsblk -f

$ df -h

$ sudo mount /dev/xvdf1 /data

$ du -sh * | sort -h

$ docker info

$ docker version

$ docker system df

$ docker system prune -a

$ docker images

$ docker ps

$ docker ps -a

$ docker run nginx

$ FROM node:18-alpine

$ WORKDIR /app

$ COPY package.json .

$ RUN npm install

$ docker volume create mydata

$ docker run -v mydata:/app/data nginx

$ docker run -v $(pwd):/app nginx

$ docker volume ls

$ docker network ls

$ docker network create mynetwork

$ docker run --network mynetwork nginx

$ docker run -p 8080:80 nginx

$ FROM node:20-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build
FROM node:20-alpine
WORKDIR /app
COPY --from=build /app/dist ./dist
CMD ["node", "dist/index.js"]

$ docker pull nginx:1.27-alpine

$ docker inspect --format='{{.RepoDigests}}' nginx:1.27-alpine

$ docker logs -f --tail=50 api

$ docker run --log-driver json-file --log-opt max-size=10m myimg

$ docker run -d --name web --restart=unless-stopped --memory=512m --cpus=0.5 nginx

$ docker exec -it web /bin/bash

$ docker stop --time=30 web

$ docker stats web

$ docker update --memory=1g --cpus=1.0 web

$ docker run --user 1001:1001 --read-only --tmpfs /tmp nginx

$ docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE nginx

$ trivy image nginx:latest

$ docker secret create db_password password.txt

$ docker run --security-opt=no-new-privileges nginx

$ docker build --target production --build-arg BUILDKIT_INLINE_CACHE=1 .

$ docker system df -v

$ docker build --cache-from myapp:latest --tag myapp:new .

$ docker run --memory=512m --oom-kill-disable=false myapp

$ docker image prune -a --filter 'until=24h'

$ docker tag myapp:latest registry.company.com/myapp:v1.2.3

$ docker push registry.company.com/myapp:v1.2.3

$ docker login -u username registry.company.com

$ docker manifest inspect nginx:latest

$ docker search --limit 5 --filter stars=100 nginx

$ docker compose up -d

$ docker compose ps

$ kubectl version --client

$ kubectl cluster-info

$ kubectl get nodes

$ kubectl get pods

$ kubectl get all

$ kubectl run nginx --image=nginx

$ kubectl get pods

$ kubectl logs nginx

$ kubectl delete pod nginx

$ kubectl create deployment nginx --image=nginx

$ kubectl get deployments

$ kubectl scale deployment nginx --replicas=3

$ kubectl delete deployment nginx

$ kubectl create configmap myconfig --from-literal=ENV=prod

$ kubectl create secret generic mysecret --from-literal=password=secret123

$ kubectl get configmaps

$ kubectl get secrets

$ kubectl expose deployment nginx --port=80

$ kubectl get services

$ kubectl describe service nginx

$ kubectl delete service nginx

$ kubectl get all -n kube-system

$ kubectl get pv,pvc

$ kubectl describe pvc my-pvc

$ kubectl get storageclass

$ readinessProbe:
  httpGet:
    path: /health
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 10

$ kubectl get statefulsets

$ kubectl scale statefulset web --replicas=5

$ kubectl get pods -l app=web

$ kubectl apply -f ingress.yaml

$ kubectl create job backup --image=backup-tool

$ kubectl get jobs,cronjobs

$ kubectl create cronjob backup --image=backup-tool --schedule='0 2 * * *'

$ kubectl get clusterrolebinding | grep admin

$ kubectl get daemonsets -A

$ kubectl describe daemonset fluentd

$ kubectl get pods -o wide -l app=monitoring

$ kubectl logs deploy/api -f

$ kubectl rollout status deploy/api

$ kubectl top pods --sort-by=cpu

$ kubectl describe pod <pod-name> | grep -A 5 Limits

$ kubectl get limitrange

$ kubectl get pods -l app=web

$ kubectl autoscale deployment nginx --cpu-percent=50 --min=1 --max=10

$ kubectl get hpa

$ kubectl describe hpa nginx

$ kubectl get networkpolicies -A

$ kubectl describe networkpolicy deny-all

$ kubectl exec -it pod1 -- curl pod2:8080

$ git push origin main

$ docker build -t app:latest .

$ git push origin main

$ npm run test:ci

$ docker build -t app:${BUILD_NUMBER} .

$ github/workflows/ci.yml

$ stages: [build, test, deploy]

$ on: [push, pull_request]

$ docker build -t registry/app:1.2.3 .

$ echo "${API_URL}"

$ git checkout -b feature/login

$ jest --coverage --ci

$ cypress run --record

$ sonar-scanner -Dsonar.projectKey=myapp

$ kubectl patch deployment app -p '{"spec":{"template":{"spec":{"containers":[{"name":"app","image":"app:v2"}]}}}'

$ istioctl kiali dashboard

$ kubectl rollout undo deployment/app

$ curl -s http://localhost:9090/metrics | grep cpu

$ docker stats --no-stream

$ sar -u 1 5

$ curl -w '%{time_total}
' -o /dev/null -s http://api.example.com

$ rate(http_requests_total[5m])

$ kubectl logs -f deployment/app --tail=100

$ trace_id=abc123 span_id=def456 duration=180ms

$ rate(http_requests_total{status=~"5.."}[5m]) > 0.1

$ prometheus --config.file=/etc/prometheus/prometheus.yml

$ sum(rate(http_requests_total[5m])) by (service)

$ grafana-cli plugins list-remote

$ curl -X GET 'localhost:9200/_search?q=error&size=10'

$ filebeat setup --dashboards

$ rate(http_requests_total{status=~"5.."}[5m]) / rate(http_requests_total[5m]) > 0.05

$ amtool silence add alertname="HighErrorRate" --duration=2h

$ curl 'http://localhost:16686/api/traces?service=frontend&limit=10'

$ otel-collector --config=otel-config.yaml

$ sum(rate(http_requests_total{status!~"5.."}[5m])) / sum(rate(http_requests_total[5m]))

$ histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))

$ sum by (service) (rate(http_requests_total[5m]))

$ grafana-cli plugins install grafana-piechart-panel

$ terraform --version

$ terraform init

$ resource "aws_s3_bucket" "logs" {
  bucket = var.bucket_name
  tags = var.common_tags
}

$ terraform fmt -recursive

$ terraform init
terraform validate
terraform plan -out=plan.tfplan
terraform apply plan.tfplan

$ terraform plan -var='environment=prod' -var-file='prod.tfvars'

$ terraform {
  required_providers {
    aws = {
      source = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

$ terraform providers lock -platform=linux_amd64 -platform=darwin_amd64

$ module "vpc" {
  source = "terraform-aws-modules/vpc/aws"
  version = "~> 5.0"
  
  name = var.vpc_name
  cidr = var.vpc_cidr
}

$ output "vpc_id" {
  value = module.vpc.vpc_id
}

$ terraform {
  backend "s3" {
    bucket = "my-terraform-state"
    key = "prod/terraform.tfstate"
    region = "us-west-2"
    dynamodb_table = "terraform-locks"
    encrypt = true
  }
}

$ terraform state mv aws_instance.web aws_instance.web_server

$ variable "environment" {
  type = string
  description = "Environment name"
  validation {
    condition = contains(["dev", "staging", "prod"], var.environment)
    error_message = "Environment must be dev, staging, or prod."
  }
}

$ output "load_balancer_dns" {
  value = aws_lb.main.dns_name
  description = "DNS name of the load balancer"
}

$ resource "aws_instance" "web" {
  tags = {
    Name = "web-${terraform.workspace}"
    Environment = terraform.workspace
  }
}

$ terraform workspace new staging && terraform workspace select staging

$ data "aws_ami" "ubuntu" {
  most_recent = true
  owners = ["099720109477"]
  filter {
    name = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*"]
  }
}

$ data "aws_availability_zones" "available" {
  state = "available"
}

$ module "vpc" {
  source = "terraform-aws-modules/vpc/aws"
  version = "~> 5.0"
  
  name = "my-vpc"
  cidr = "10.0.0.0/16"
}

$ terraform {
  required_providers {
    aws = {
      source = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

$ java -jar jenkins.war --httpPort=8080

$ curl -X GET http://localhost:8080/api/json

$ agent {
  kubernetes {
    yaml '''
      apiVersion: v1
      kind: Pod
      spec:
        containers:
        - name: maven
          image: maven:3.8.1-jdk-11
    '''
  }
}

$ agent { label 'linux && docker' }

$ pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh 'npm ci'
        sh 'npm run build'
      }
    }
  }
}

$ node {
  stage('Checkout') {
    checkout scm
  }
  stage('Build') {
    sh 'make build'
  }
}

$ pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        sh 'go test ./...'
      }
    }
  }
  post {
    always {
      junit 'test-results.xml'
    }
  }
}

$ @Library('shared-library') _

pipeline {
  agent any
  stages {
    stage('Deploy') {
      steps {
        deployToEnvironment('staging')
      }
    }
  }
}

$ stages {
  stage('Build') {
    steps {
      sh 'mvn clean compile'
    }
  }
  stage('Test') {
    parallel {
      stage('Unit Tests') {
        steps {
          sh 'mvn test'
        }
      }
      stage('Integration Tests') {
        steps {
          sh 'mvn integration-test'
        }
      }
    }
  }
}

$ stage('Deploy') {
  when {
    branch 'main'
  }
  steps {
    sh 'kubectl apply -f deployment.yaml'
  }
}

$ # plugins.txt
git:latest
pipeline-stage-view:latest
blue-ocean:latest
docker-plugin:latest
kubernetes:latest

$ jenkins-plugin-cli --plugin-file plugins.txt --plugin-download-directory /var/jenkins_home/plugins

$ triggers {
  pollSCM('H/15 * * * *')
  cron('@daily')
  upstream(upstreamProjects: 'upstream-job', threshold: hudson.model.Result.SUCCESS)
}

$ curl -X POST -H 'Authorization: Bearer TOKEN' http://jenkins/job/my-job/build

$ withCredentials([
  usernamePassword(credentialsId: 'docker-hub', usernameVariable: 'DOCKER_USER', passwordVariable: 'DOCKER_PASS'),
  string(credentialsId: 'api-token', variable: 'API_TOKEN')
]) {
  sh 'docker login -u $DOCKER_USER -p $DOCKER_PASS'
  sh 'curl -H "Authorization: Bearer $API_TOKEN" api.example.com'
}

$ environment {
  VAULT_ADDR = 'https://vault.company.com'
  VAULT_NAMESPACE = 'jenkins'
}

$ pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh 'make build'
        archiveArtifacts artifacts: 'dist/**/*.jar', fingerprint: true
        publishHTML([
          allowMissing: false,
          alwaysLinkToLastBuild: true,
          keepAll: true,
          reportDir: 'reports',
          reportFiles: 'index.html',
          reportName: 'Build Report'
        ])
      }
    }
  }
  post {
    always {
      cleanWs()
    }
  }
}

$ stash includes: 'target/**/*.jar', name: 'build-artifacts'
// Later stage
unstash 'build-artifacts'

$ pipeline {
  agent {
    kubernetes {
      yaml '''
        apiVersion: v1
        kind: Pod
        spec:
          containers:
          - name: maven
            image: maven:3.8.1-jdk-11
            command:
            - sleep
            args:
            - 99d
      '''
    }
  }
  stages {
    stage('Build') {
      steps {
        container('maven') {
          sh 'mvn clean package'
        }
      }
    }
  }
}

$ agent {
  label 'linux && docker && high-memory'
}

$ git --version

$ git clone https://github.com/user/repo.git

$ git status --porcelain

$ git log --oneline --graph --all

$ git init
git add README.md
git commit -m 'Initial commit'
git remote add origin https://github.com/user/repo.git
git push -u origin main

$ git add -p

$ git checkout -b feature/user-auth
git push -u origin feature/user-auth

$ git branch --merged | grep -v main | xargs git branch -d

$ git merge feature/api
# If conflicts occur:
git status
# Edit conflicted files
git add .
git commit

$ git rebase -i HEAD~3

$ git remote add upstream https://github.com/original/repo.git
git fetch upstream
git merge upstream/main

$ git push --force-with-lease origin feature-branch

$ # .github/workflows/ci.yml
name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: npm test

$ gh pr create --title 'Add new feature' --body 'Description of changes'

$ git stash push -m 'WIP: user authentication feature'
git checkout hotfix-branch
# Make hotfix
git checkout feature-branch
git stash pop

$ git stash show -p stash@{1}

$ # .gitignore
# Dependencies
node_modules/
*.log

# Build outputs
dist/
build/

# Environment
.env
.env.local

# IDE
.vscode/
*.swp

$ git config --global core.excludesfile ~/.gitignore_global

$ git tag -a v1.2.0 -m 'Release 1.2.0: Added user authentication'
git push origin v1.2.0

$ git describe --tags --abbrev=0

$ git rebase -i HEAD~3
# In editor: change 'pick' to 'squash' for commits to combine
# Save and edit commit message

$ git bisect start
git bisect bad HEAD
git bisect good v1.0.0
# Test each commit Git presents
git bisect good/bad
git bisect reset

$ # ~/.gitconfig
[user]
    name = John Doe
    email = john@example.com
[alias]
    st = status -sb
    co = checkout
    br = branch
    unstage = reset HEAD --
[includeIf "gitdir:~/work/"]
    path = ~/.gitconfig-work

$ git config --global core.hooksPath ~/.githooks

$ git clone https://github.com/company/k8s-configs.git
cd k8s-configs
kubectl apply -f apps/production/

$ # .github/workflows/validate.yml
name: Validate Manifests
on: [push, pull_request]
jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: kubectl apply --dry-run=client -f manifests/

$ # Declarative Kubernetes manifest
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: web
        image: nginx:1.21

$ git log --oneline --graph
git show <commit-hash>
git revert <commit-hash>

$ kubectl apply -f manifests/ (performed by controller)

$ apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: web-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/company/k8s-configs
    targetRevision: HEAD
    path: apps/web-app
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

$ argocd app create web-app \
  --repo https://github.com/company/k8s-configs \
  --path apps/web-app \
  --dest-server https://kubernetes.default.svc \
  --dest-namespace production

$ flux create source git webapp \
  --url=https://github.com/company/k8s-configs \
  --branch=main \
  --interval=1m

flux create kustomization webapp \
  --target-namespace=production \
  --source=webapp \
  --path="./apps/webapp" \
  --prune=true \
  --interval=5m

$ apiVersion: helm.toolkit.fluxcd.io/v2beta1
kind: HelmRelease
metadata:
  name: nginx
  namespace: default
spec:
  interval: 5m
  chart:
    spec:
      chart: nginx
      version: '1.x'
      sourceRef:
        kind: HelmRepository
        name: bitnami
  values:
    replicaCount: 3

$ # Pull-based reconciliation loop
while true; do
  git fetch origin main
  kubectl diff -f manifests/
  kubectl apply -f manifests/
  kubectl get events --sort-by='.lastTimestamp'
  sleep 30
done

$ # Push-based deployment (traditional)
# In CI/CD pipeline:
kubectl config use-context production
kubectl apply -f manifests/

# vs Pull-based (GitOps)
# Agent in cluster:
flux reconcile kustomization webapp --with-source

$ # GitOps Repository Structure
k8s-configs/
├── apps/
│   ├── web-app/
│   │   ├── base/
│   │   │   ├── deployment.yaml
│   │   │   ├── service.yaml
│   │   │   └── kustomization.yaml
│   │   └── overlays/
│   │       ├── dev/
│   │       ├── staging/
│   │       └── production/
│   └── api-service/
├── infrastructure/
│   ├── namespaces/
│   ├── rbac/
│   └── monitoring/
└── clusters/
    ├── dev-cluster/
    ├── staging-cluster/
    └── prod-cluster/

$ # Kustomization overlay example
# overlays/production/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
- ../../base
replicas:
- name: web-app
  count: 5
images:
- name: web-app
  newTag: v1.2.3

$ # Sealed Secret example
apiVersion: bitnami.com/v1alpha1
kind: SealedSecret
metadata:
  name: db-credentials
  namespace: production
spec:
  encryptedData:
    username: AgBy3i4OJSWK+PiTySYZZA9rO43cGDEQAx...
    password: AgBy3i4OJSWK+PiTySYZZA9rO43cGDEQAx...

$ # External Secrets Operator
apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: vault-secret
spec:
  refreshInterval: 15s
  secretStoreRef:
    name: vault-backend
    kind: SecretStore
  target:
    name: db-credentials
  data:
  - secretKey: username
    remoteRef:
      key: database
      property: username

$ # Branch-per-environment workflow
git checkout dev
git add .
git commit -m 'Add new feature'
git push origin dev

# Promote to staging
git checkout staging
git merge dev
git push origin staging

# Promote to production
git checkout main
git merge staging
git push origin main

$ # Directory-per-environment with Kustomize
envs/
├── base/
│   ├── deployment.yaml
│   └── kustomization.yaml
├── dev/
│   ├── kustomization.yaml
│   └── replica-patch.yaml
├── staging/
│   ├── kustomization.yaml
│   └── resource-patch.yaml
└── production/
    ├── kustomization.yaml
    └── production-patch.yaml

$ # Audit trail example
git log --oneline --graph --all
* 2f8a9c1 (HEAD -> main) Update production replicas to 5
* 1a7b3d2 Add health check endpoint
* 9e4f6c8 Initial application deployment

# Rollback example
git revert 2f8a9c1
# This creates a new commit that undoes the replica change

$ # Measuring GitOps success
# Deployment frequency
git log --since='1 month ago' --oneline | wc -l

# Lead time (commit to deployment)
kubectl get applications -o json | jq '.items[] | {name: .metadata.name, lastSync: .status.operationState.finishedAt}'

# Change failure rate
kubectl get events --field-selector reason=Failed

$ name: CI Pipeline
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm test
  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - run: npm run deploy

$ jobs:
  build:
    outputs:
      version: ${{ steps.version.outputs.value }}
    steps:
      - id: version
        run: echo "value=1.0.0" >> $GITHUB_OUTPUT

$ .github/workflows/
├── ci.yml          # Continuous Integration
├── deploy.yml       # Deployment
├── release.yml      # Release Management
└── security.yml     # Security Scanning

$ name: "CI Pipeline"
on: [push, pull_request]
# Workflow content here

$ on:
  push:
    branches: [main, develop]
    paths: ['src/**', '!docs/**']
  pull_request:
    types: [opened, synchronize]
  schedule:
    - cron: '0 2 * * 1-5'
  workflow_dispatch:
    inputs:
      environment:
        description: 'Environment to deploy'
        required: true
        default: 'staging'

$ on:
  release:
    types: [published]
  repository_dispatch:
    types: [deploy-prod]

$ jobs:
  test:
    runs-on: ubuntu-latest
  build:
    runs-on: [self-hosted, linux, large]
  deploy:
    runs-on: ubuntu-latest
    container:
      image: node:18
      options: --cpus 2

$ runs-on: ${{ matrix.os }}
strategy:
  matrix:
    os: [ubuntu-latest, windows-latest, macos-latest]

$ steps:
  - uses: actions/checkout@v4
  - uses: actions/setup-node@v4
    with:
      node-version: '18'
      cache: 'npm'
  - uses: actions/upload-artifact@v4
    with:
      name: build-files
      path: dist/

$ uses: ./.github/actions/custom-deploy
with:
  environment: production
  api-key: ${{ secrets.API_KEY }}

$ env:
  NODE_ENV: production
  API_URL: https://api.example.com
jobs:
  deploy:
    environment: production
    steps:
      - run: |
          echo "Deploying to $NODE_ENV"
          curl -H "Authorization: Bearer ${{ secrets.API_TOKEN }}" $API_URL

$ permissions:
  contents: read
  issues: write
  pull-requests: write

$ - name: Cache dependencies
  uses: actions/cache@v4
  with:
    path: |
      ~/.npm
      ~/.cache/pip
      target/
    key: ${{ runner.os }}-deps-${{ hashFiles('**/package-lock.json', '**/requirements.txt', '**/Cargo.lock') }}
    restore-keys: |
      ${{ runner.os }}-deps-
      ${{ runner.os }}-

$ - uses: actions/upload-artifact@v4
  with:
    name: build-${{ github.sha }}
    path: |
      dist/
      coverage/
    retention-days: 30

$ permissions:
  contents: read
  issues: write
  pull-requests: write
  id-token: write  # for OIDC
steps:
  - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
  - name: Configure AWS
    uses: aws-actions/configure-aws-credentials@v4
    with:
      role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
      aws-region: us-east-1

$ - name: Validate input
  env:
    USER_INPUT: ${{ github.event.inputs.message }}
  run: |
    # Safe: using environment variable
    echo "Processing: $USER_INPUT"

$ strategy:
  fail-fast: false
  matrix:
    os: [ubuntu-latest, windows-latest, macos-latest]
    node: [18, 20]
    include:
      - os: ubuntu-latest
        node: 16
        experimental: true
    exclude:
      - os: macos-latest
        node: 18

$ runs-on: ${{ matrix.os }}
steps:
  - run: echo "Testing on ${{ matrix.os }} with Node ${{ matrix.node }}"