LI440: Git Competence as Operational Reliability NEW

Agenda:

• The Foundation - How Git thinks and stores
  • A shared mental model forms the basis for any reliable collaboration.
    • Internal workings of Git: objects, trees, commits
    • DVCS vs. centralized systems: impact on daily work
    • The staging area as a quality step: targeted committing of changes
    • Core basic commands: init, add, commit, status, log, diff
    • Use of .gitignore to exclude infrastructure artifacts and secrets
      
      
• Team Coordination - Working in parallel without collision risk
  • Multiple people working simultaneously on the same infrastructure represent a structural risk without clear rules.
    • Branch concepts and strategies:
    • Feature branches
    • Long-lived branches
    • Trunk-based development
    • Merge strategies and when to use which
    • Remote workflows:
      • push
      • pull
      • fetch - what actually happens?
    • Recognizing and resolving conflicts in IaC repositories in a targeted manner
    • Comparison of typical team workflows:
      • GitFlow
      • Trunk-based
      • GitOps workflow
        
        
• Traceability - The history as an audit trail
  • Who changed which infrastructure component, when—and why?
    • Writing good commit messages:
      • The why, not the what
    • git log, git blame, git bisect:
      • Finding root causes in large histories
    • Rebase vs. merge: trade-offs for clean vs. complete history
    • Interactive rebase:
      • Keeping history readable without falsifying it
    • Anti-patterns that destroy the audit trail—and how to avoid them
      
      
• Operational Reliability - Detect, isolate, and revert errors
  • No system runs error-free. The decisive question is how quickly the team can react.
    • git reset, git revert, git restore:
      • Knowing the right switch in emergencies
    • cherry-pick:
      • Retrieving a single fix from a branch
    • git stash:
      • Cleanly parking interrupted work
    • git reflog:
      • The last line of defense
    • The last line of defense—even after seemingly destructive actions
    • Rollback scenarios in practice:
      • from commit to production deployment
        
        
• Automation & GitOps - Enforce quality instead of hoping for it
  • Manual processes do not scale.
    • Git hooks:
      • Automating quality checks locally (pre-commit, commit-msg)
    • CI/CD integration:
      • How Git events trigger pipelines
    • Branch protection rules and pull request
    • Workflows as quality gates
    • The GitOps model:
      • Git as a single source of truth for Kubernetes and IaC
    • Overview:
      • GitHub Actions
      • GitLab CI
      • ArgoCD
    • Interaction with Git

Objectives:

• explain Git’s internal object model and derive the difference between Working Tree, Index, and Repository
• read git status and git log in a way that allows them to reliably assess the state of a repository
• create commits with meaningful messages suitable as an audit trail for compliance and incident analysis
• use branches purposefully and select merge strategies appropriately for the situation
• understand remote workflows (push, pull, fetch) and independently resolve conflicts in IaC repositories
• choose and justify the appropriate team workflow (GitFlow, Trunk-based, GitOps) for their environment
• apply rebase techniques confidently—and know when rebase is prohibited
• use Git history as a tool for troubleshooting (git bisect, git blame, git log –graph)
• act in a targeted manner in emergencies: use reset, revert, cherry-pick, and reflog appropriately
• roll back a faulty deployment in a controlled manner without losing additional data
• set up Git hooks for local quality assurance
• configure branch protection rules and pull request workflows as technically enforced quality gates
• explain the GitOps model and use Git as a single source of truth for Kubernetes deployments and IaC
  repositories
• understand the basic principles of CI/CD integration with Git and name typical trigger mechanisms

Target audience:

• DevOps Engineers and Site Reliability Engineers (SREs)
• System administrators who are or will be involved in GitOps workflows
• Platform Engineers responsible for Git-based deployment processes
• Operations Leads who want to establish binding Git conventions for their team
• IT admins working with Terraform, Ansible, Kubernetes manifests, or similar IaC tools

Prerequisites:

• Bash fundamentals (Linux): confident use of the terminal, especially navigation in directories, creating and editing files, and using simple pipes and redirections. Although Git is platform-independent, the course examples and lab environments are based on Linux, as this reflects the typical operating context of DevOps
  and GitOps workflows.
• Basic understanding of version control: general understanding of tracking changes; experience with systems such as SVN or comparable solutions is sufficient.

• Programming knowledge
• Prior Git knowledge
• Experience with specific Infrastructure-as-Code tools (e.g., Terraform, Ansible)

Description: