Azure DevOps Fundamentals

brew install git
git --version

winget install --id Git.Git
git --version

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global core.editor "code --wait"
git config --list

# Initialise repo
mkdir myproject && cd myproject
git init

# Stage and commit
echo "Hello" > index.txt
git add index.txt           # stage specific file
git add .                   # stage everything
git status
git commit -m "Initial commit"

# History
git log
git log --oneline --graph --all

# Unstage a file
git restore --staged index.txt

# Show what changed in a commit
git show HEAD
git diff HEAD~1 HEAD

# Create and switch branches
git branch feature/login
git checkout feature/login
# or in one step:
git checkout -b feature/login

# List branches
git branch -a

# Make a commit on feature branch
echo "login page" > login.txt
git add . && git commit -m "Add login page"

# Switch back to main
git checkout main

# See branch graph
git log --oneline --graph --all --decorate

# Merge feature branch into main
git checkout main
git merge feature/login           # fast-forward if possible
git merge --no-ff feature/login   # always create merge commit

# Resolve a conflict
# After conflict: edit file, remove markers
git add conflicted-file.txt
git commit -m "Resolve merge conflict"

# Tags
git tag v1.0.0                              # lightweight
git tag -a v1.0.0 -m "Release 1.0.0"       # annotated
git tag                                     # list tags
git push origin v1.0.0                     # push tag
git push origin --tags                     # push all tags

# Delete a branch after merge
git branch -d feature/login

# Rebase feature onto main
git checkout feature/login
git rebase main

# Interactive rebase — squash last 3 commits
git rebase -i HEAD~3
# In editor: change 'pick' to 'squash' or 's' for commits to merge

# Stash
git stash                      # stash current changes
git stash list                 # list stashes
git stash pop                  # apply and drop latest stash
git stash apply stash@{1}      # apply specific stash

# Amend last commit
git commit --amend -m "Better message"

# Reset (use carefully)
git reset --soft HEAD~1    # undo commit, keep staged
git reset --mixed HEAD~1   # undo commit, unstage files
git reset --hard HEAD~1    # undo commit, discard changes

# Generate SSH key
ssh-keygen -t ed25519 -C "you@example.com"
cat ~/.ssh/id_ed25519.pub   # copy this to Azure DevOps

# Clone via SSH
git clone git@ssh.dev.azure.com:v3/org/project/repo

# Remote operations
git remote -v                          # list remotes
git remote add origin <url>
git fetch origin                       # download without merging
git pull origin main                   # fetch + merge
git push origin feature/login          # push branch
git push -u origin feature/login       # push + set tracking

# See remote branches
git branch -r
git branch -a

# Install Azure DevOps extension
az extension add --name azure-devops

# Configure defaults
az devops configure --defaults \
  organization=https://dev.azure.com/yourorg \
  project=YourProject

# Create repo
az repos create --name my-repo

# List repos
az repos list --output table

# Create PR
az repos pr create \
  --repository my-repo \
  --source-branch feature/login \
  --target-branch main \
  --title "Add login page" \
  --description "Adds login functionality"

# List PRs
az repos pr list --output table

# Install Maven
brew install maven          # Mac
# or download from maven.apache.org

mvn --version

# Create a new project
mvn archetype:generate \
  -DgroupId=com.dpworld \
  -DartifactId=myapp \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false

cd myapp

# Maven commands
mvn compile          # compile source
mvn test             # run tests
mvn package          # create JAR
mvn clean package    # clean then package
mvn install          # install to local repo

# Skip tests (use sparingly)
mvn package -DskipTests

# Create .NET app
dotnet new webapi -n MyApi
cd MyApi

# Restore, build, test, publish
dotnet restore
dotnet build
dotnet test
dotnet publish -c Release -o ./out

# Run locally
dotnet run

# Add NuGet package
dotnet add package Newtonsoft.Json

# List packages
dotnet list package

# Run SonarQube via Docker (easiest for lab)
docker run -d \
  --name sonarqube \
  -p 9000:9000 \
  -e SONAR_ES_BOOTSTRAP_CHECKS_DISABLE=true \
  sonarqube:community

# Access at http://localhost:9000
# Default login: admin / admin
# Change password on first login

steps:
- task: SonarQubePrepare@5
  inputs:
    SonarQube: 'SonarQube-ServiceConnection'
    scannerMode: 'CLI'
    configMode: 'manual'
    cliProjectKey: 'my-project'
    cliSources: '.'

- script: dotnet build

- task: SonarQubeAnalyze@5

- task: SonarQubePublish@5
  inputs:
    pollingTimeoutSec: '300'

trigger:
  - main

pool:
  vmImage: ubuntu-latest

steps:
  - script: echo "Hello from Azure Pipelines!"
    displayName: 'First step'

  - script: |
      echo "Multi-line script"
      echo "Current directory: $(pwd)"
    displayName: 'Multi-line step'

trigger:
  - main

pool:
  vmImage: ubuntu-latest

stages:

- stage: Build
  jobs:
  - job: BuildApp
    steps:
    - script: echo "Building..."
    - script: dotnet build

- stage: Test
  dependsOn: Build
  jobs:
  - job: RunTests
    steps:
    - script: dotnet test --logger trx
    - task: PublishTestResults@2
      inputs:
        testResultsFormat: VSTest
        testResultsFiles: '**/*.trx'

- stage: Deploy
  dependsOn: Test
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  jobs:
  - deployment: DeployProd
    environment: production
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to prod"

# Create service principal with Contributor on resource group
az ad sp create-for-rbac \
  --name "sp-devops-pipeline" \
  --role Contributor \
  --scopes /subscriptions/<sub-id>/resourceGroups/rg-prod

# Output contains appId, password, tenant
# Add these to Azure DevOps Service Connection

# Use service connection in pipeline
# Project Settings → Service connections → New → Azure Resource Manager

- task: AzureCLI@2
  inputs:
    azureSubscription: 'MyAzureServiceConnection'
    scriptType: 'bash'
    scriptLocation: 'inlineScript'
    inlineScript: |
      az group list -o table

variables:
  - group: my-variable-group        # link variable group
  - name: appName
    value: 'myapp'

stages:
- stage: DeployDev
  jobs:
  - deployment: Deploy
    environment: dev                  # environment with optional approval
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying $(appName) to dev"

- stage: DeployProd
  dependsOn: DeployDev
  jobs:
  - deployment: Deploy
    environment: production           # requires approval gate configured in portal
    strategy:
      runOnce:
        deploy:
          steps:
          - script: echo "Deploying to prod"

trigger:
  - main

pool:
  vmImage: ubuntu-latest

variables:
  buildConfiguration: Release

stages:
- stage: Build
  jobs:
  - job: Build
    steps:
    - task: DotNetCoreCLI@2
      displayName: Restore
      inputs:
        command: restore
        projects: '**/*.csproj'

    - task: DotNetCoreCLI@2
      displayName: Build
      inputs:
        command: build
        arguments: '--configuration $(buildConfiguration)'

    - task: DotNetCoreCLI@2
      displayName: Test
      inputs:
        command: test
        arguments: '--configuration $(buildConfiguration) --collect "Code coverage"'

    - task: DotNetCoreCLI@2
      displayName: Publish
      inputs:
        command: publish
        arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'

    - task: PublishBuildArtifacts@1
      inputs:
        pathToPublish: $(Build.ArtifactStagingDirectory)
        artifactName: drop

trigger:
  - main

pool:
  vmImage: ubuntu-latest

steps:
- task: JavaToolInstaller@0
  inputs:
    versionSpec: '17'
    jdkArchitectureOption: x64
    jdkSourceOption: PreInstalled

- task: Maven@3
  displayName: Build and Test
  inputs:
    mavenPomFile: pom.xml
    goals: clean package
    publishJUnitResults: true
    testResultsFiles: '**/surefire-reports/TEST-*.xml'
    javaHomeOption: JDKVersion
    jdkVersionOption: '1.17'

- task: CopyFiles@2
  inputs:
    contents: '**/target/*.jar'
    targetFolder: $(Build.ArtifactStagingDirectory)

- task: PublishBuildArtifacts@1
  inputs:
    artifactName: jar-output

- task: NuGetAuthenticate@1

- task: DotNetCoreCLI@2
  displayName: Pack NuGet
  inputs:
    command: pack
    packagesToPack: '**/*.csproj'
    versioningScheme: byBuildNumber

- task: DotNetCoreCLI@2
  displayName: Push to Feed
  inputs:
    command: push
    packagesToPush: '$(Build.ArtifactStagingDirectory)/**/*.nupkg'
    nuGetFeedType: internal
    publishVstsFeed: 'MyProject/my-feed'

- task: NuGetAuthenticate@1

- task: DotNetCoreCLI@2
  inputs:
    command: restore
    feedsToUse: select
    vstsFeed: 'MyProject/my-feed'

trigger:
  branches:
    include:
      - main
      - release/*
    exclude:
      - feature/*
  paths:
    include:
      - src/
    exclude:
      - docs/

pr:
  branches:
    include:
      - main
  paths:
    include:
      - src/

# Install Docker Desktop (Mac/Windows) from docker.com
docker version
docker info

# Run first container
docker run hello-world
docker run -it ubuntu bash    # interactive
docker run -d nginx           # detached

# List containers
docker ps                     # running
docker ps -a                  # all including stopped

# Image management
docker pull nginx:alpine
docker images
docker image inspect nginx:alpine
docker rmi nginx:alpine

# Container with port and volume
docker run -d \
  --name myapp \
  -p 8080:80 \
  -v $(pwd)/html:/usr/share/nginx/html \
  -e MY_VAR=hello \
  nginx:alpine

# Exec into running container
docker exec -it myapp sh

# Logs
docker logs myapp -f

# Stop and remove
docker stop myapp && docker rm myapp

# Named volume
docker volume create mydata
docker run -d -v mydata:/data postgres

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish -c Release -o /app/out

FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY --from=build /app/out .
EXPOSE 8080
ENTRYPOINT ["dotnet", "MyApi.dll"]

version: '3.8'
services:
  api:
    build: .
    ports: ["8080:8080"]
    depends_on: [db]
    environment:
      - ConnectionString=Host=db;Database=mydb
  db:
    image: postgres:16
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=secret
volumes:
  pgdata:

docker build -t myapp:1.0 .
docker compose up -d
docker compose logs -f
docker compose down

# Create ACR
az acr create --name myregistry --resource-group rg-lab --sku Basic

# Login
az acr login --name myregistry

# Tag and push
docker tag myapp:1.0 myregistry.azurecr.io/myapp:1.0
docker push myregistry.azurecr.io/myapp:1.0

# List images in ACR
az acr repository list --name myregistry -o table

# Docker Swarm init (single node)
docker swarm init
docker service create --name web --replicas 3 -p 80:80 nginx
docker service ls
docker service scale web=5

# Create overlay network
docker network create --driver overlay my-overlay

# Deploy stack from compose file
docker stack deploy -c docker-compose.yml mystack

# Manage stack
docker stack ls
docker stack ps mystack
docker stack services mystack
docker stack rm mystack

# Secrets
echo "mysecretpassword" | docker secret create db_password -
docker service create \
  --name db \
  --secret db_password \
  postgres:16

az login
az account list -o table
az account set --subscription "<id>"

# Create resource group
az group create --name rg-lab --location uaenorth

# List resources
az resource list --resource-group rg-lab -o table

# RBAC — assign role
az role assignment create \
  --assignee <user-or-sp-objectId> \
  --role Contributor \
  --scope /subscriptions/<sub-id>/resourceGroups/rg-lab

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 3.0"
    }
  }
}

provider "azurerm" {
  features {}
}

variable "location" {
  default = "uaenorth"
}

resource "azurerm_resource_group" "rg" {
  name     = "rg-terraform-lab"
  location = var.location
  tags = {
    managedBy = "terraform"
  }
}

output "rg_id" {
  value = azurerm_resource_group.rg.id
}

terraform init
terraform plan
terraform apply
terraform show
terraform destroy

terraform {
  backend "azurerm" {
    resource_group_name  = "rg-tfstate"
    storage_account_name = "tfstatestorage"
    container_name       = "tfstate"
    key                  = "prod.terraform.tfstate"
  }
}

terraform workspace new dev
terraform workspace new prod
terraform workspace select dev
terraform workspace list

- task: AzureResourceManagerTemplateDeployment@3
  inputs:
    deploymentScope: Resource Group
    azureResourceManagerConnection: 'MyServiceConnection'
    subscriptionId: '$(subscriptionId)'
    action: Create Or Update Resource Group
    resourceGroupName: rg-prod
    location: uaenorth
    templateLocation: Linked artifact
    csmFile: infra/main.bicep
    csmParametersFile: infra/main.bicepparam
    deploymentMode: Incremental

stages:
- stage: Plan
  jobs:
  - job: TerraformPlan
    steps:
    - task: TerraformInstaller@1
      inputs:
        terraformVersion: 'latest'

    - task: TerraformTaskV4@4
      displayName: Terraform Init
      inputs:
        provider: azurerm
        command: init
        backendServiceArm: 'MyServiceConnection'
        backendAzureRmResourceGroupName: rg-tfstate
        backendAzureRmStorageAccountName: tfstatestorage
        backendAzureRmContainerName: tfstate
        backendAzureRmKey: prod.tfstate

    - task: TerraformTaskV4@4
      displayName: Terraform Plan
      inputs:
        provider: azurerm
        command: plan
        environmentServiceNameAzureRM: 'MyServiceConnection'

- stage: Apply
  dependsOn: Plan
  jobs:
  - deployment: TerraformApply
    environment: production
    strategy:
      runOnce:
        deploy:
          steps:
          - task: TerraformTaskV4@4
            inputs:
              provider: azurerm
              command: apply
              environmentServiceNameAzureRM: 'MyServiceConnection'

# Install minikube
brew install minikube

# Start cluster (uses Docker as driver)
minikube start --driver=docker --cpus=2 --memory=4096

# Check status
minikube status

# Get cluster info
kubectl cluster-info
kubectl get nodes          # shows 1 node: minikube

# Useful minikube commands
minikube dashboard         # opens Kubernetes dashboard in browser
minikube stop              # stop cluster (preserves state)
minikube delete            # delete cluster completely
minikube ssh               # SSH into the minikube VM/container

# Install minikube
winget install Kubernetes.minikube

# Start cluster
minikube start --driver=docker --cpus=2 --memory=4096

# Verify
kubectl get nodes
minikube status

# Install kind
brew install kind                         # Mac
# Windows: winget install Kubernetes.kind

# Create single-node cluster
kind create cluster --name lab-cluster

# Multi-node cluster (1 control plane + 2 workers)
cat <