LI440: Git for DevOps & Operations: Workflows, Rollback, GitOps 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:

After completing the course LI440 Git for DevOps & Operations: Workflows, Rollback, GitOps, participants will be able to:

• 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:

The course LI440 Git for DevOps & Operations: Workflows, Rollback, GitOps is designed for DevOps teams and operations staff who use or plan to use Git in the context of Infrastructure-as-Code, Kubernetes environments, and CI/CD pipelines.

It is particularly suitable for:

• 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

The course is not primarily designed for software developers. Those who mainly develop application code will recognize many concepts—however, the focus and examples are consistently oriented toward infrastructure and operations.

Prerequisites:

No prior Git knowledge is required to attend the LI440 Git for DevOps & Operations: Workflows, Rollback, GitOps course. The course starts with the mental model and develops the content step by step.

The following basic knowledge is required:

• 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 skills, prior knowledge of Git, and experience with specific Infrastructure-as-Code tools (e.g., Terraform, Ansible) are not required.

Description:

The course LI440 Git for DevOps & Operations: Workflows, Rollback, GitOps is aimed at DevOps teams that already use Git but have not yet established a unified and reliable way of working.
Along five operational pillars, the course  conveys a structured and field-proven approach: from the fundamentals of a robust mental model through team coordination and traceability to emergency procedures and GitOps automation. The objective is to build the decisive competence that makes the difference in daily operations—between merely using Git and mastering it confidently. A particular focus lies on the GitOps paradigm as a deployment model for Kubernetes environments as well as for Infrastructure-as-Code repositories.
Hands-on exercises accompany all topics throughout: from structured commit history to full rollback of faulty deployments.