Home/Modul 3

🦊 Modul 3: GitLab für Netzwerkteams

Lernziele: Sie können GitLab-Projekte verwalten, Merge Requests erstellen, Code Reviews durchführen und verstehen, wie CI/CD-Pipelines funktionieren.

⏱️ Dauer: ca. 105 Minuten (inkl. 7 Praxis-Übungen)

📋 Inhaltsübersicht

  • 1. Was ist GitLab?
  • 2. Die GitLab-Oberfläche im Detail
  • 3. Projekte und Groups
  • 4. Protected Branches
  • 5. Merge Request Workflow
  • 6. Code Review Best Practices
  • 7. Issues und Boards
  • 8. CI/CD Pipeline Grundlagen

1. Was ist GitLab?

GitLab ist wie ein Bürogebäude für Ihren Code: Git speichert die Dateien, aber GitLab bietet die Infrastruktur drumherum – Projektverwaltung, Zugriffsrechte, Code Reviews, und automatische Pipelines.

💡GitLab vs. Git
Git = Das Werkzeug zur Versionskontrolle (lokal auf Ihrem Rechner)
GitLab = Die Plattform zum Teilen, Reviewen und Automatisieren (im Browser)

GitLab Kernfunktionen

📁 Repositories

Zentrale Ablage für Code und Konfigurationsdateien. Zugänglich für das ganze Team.

🔀 Merge Requests

Änderungen vorschlagen, reviewen und diskutieren, bevor sie live gehen.

⚙️ CI/CD Pipelines

Automatische Tests und Deployments bei jedem Push.

📋 Issues & Boards

Aufgaben und Bugs verfolgen, Arbeit planen und dokumentieren.

GitLab vs. GitHub – Kurzer Vergleich

Beide Plattformen bieten ähnliche Funktionen. Hier die wichtigsten Unterschiede:

Aspekt🦊 GitLab🐙 GitHub
Self-Hosting✅ Kostenlos möglich (CE)💰 Enterprise-Lizenz nötig
CI/CD integriert✅ Vollständig eingebaut✅ GitHub Actions
Merge Request / PRMerge Request (MR)Pull Request (PR)
DevOps-Fokus✅ All-in-One PlattformEher Developer-fokussiert
Enterprise-EinsatzSehr verbreitet (on-prem)Dominiert Open Source
ℹ️Warum GitLab im Enterprise?
Viele Unternehmen (inkl. Cisco-Kunden) nutzen GitLab, weil es:
  • On-Premise installiert werden kann (Datenschutz)
  • CI/CD ohne externe Tools bietet
  • LDAP/Active Directory Integration hat
  • Approval-Workflows für Compliance unterstützt

2. Die GitLab-Oberfläche im Detail

Wenn Sie GitLab zum ersten Mal öffnen, sehen Sie die Hauptnavigation. Lassen Sie uns die wichtigsten Bereiche erkunden.

GitLab Dashboard mit Projektübersicht und Navigation
🔍 Vergrößern
GitLab Dashboard – Ihre zentrale Anlaufstelle für alle Projekte

Die linke Seitenleiste

🦊GitLab
📁 Ihr Projekt
├── 📋 Project information
├── 📂 Repository
│ ├── Files
│ ├── Commits
│ ├── Branches
│ └── Tags
├── 📝 Issues
├── 🔀 Merge requests
├── ⚙️ CI/CD
│ ├── Pipelines
│ └── Jobs
├── 📊 Analytics
└── ⚙️ Settings

Wichtige Bereiche erklärt

📂 Repository → Files

Hier sehen Sie alle Dateien Ihres Projekts. Sie können Dateien direkt im Browser bearbeiten, die History einsehen und zwischen Branches wechseln.

GitLab Repository-Ansicht mit Dateiliste und Ordnerstruktur
🔍 Vergrößern
Die Repository-Ansicht zeigt alle Dateien und Ordner Ihres Projekts

📂 Repository → Branches

Übersicht aller Branches. Zeigt an, welche Branches aktiv sind, wann der letzte Commit war und ob sie protected sind. Hier können Sie auch neue Branches erstellen.

🔀 Merge Requests

Alle offenen, gemergten und geschlossenen Merge Requests. Filter nach Author, Reviewer, Labels oder Milestone möglich.

⚙️ Settings

Projekteinstellungen: Zugriffsrechte, Protected Branches, Webhooks, CI/CD-Variablen, Merge Request Approvals und vieles mehr.

🔧🔧 Übung 1: GitLab erkunden und Projekt anlegen (~10 Min)

Machen Sie sich mit der GitLab-Oberfläche vertraut.

  1. Öffnen Sie GitLab im Browser (URL vom Instructor)
  2. Neues Projekt erstellen:
    • Klicken Sie auf New project
    • Wählen Sie Create blank project
    • Name: netzwerk-config-IHRNAME
    • Visibility: Private
    • ✅ "Initialize repository with a README" aktivieren
  3. Projekt erkunden:
    • Öffnen Sie Repository → Files
    • Schauen Sie sich Repository → Commits an
    • Öffnen Sie Settings → General
  4. Projekt klonen:

    Öffnen Sie PowerShell und navigieren Sie zu Ihrem Desktop:

    cd C:\Users\admin\Desktop
    
    # SSL-Verifikation deaktivieren (self-signed Zertifikat)
    git config --global http.sslVerify false
    
    # HTTPS-URL aus GitLab kopieren (Clone-Button)
    git clone https://198.18.133.100/gitlab-instance-668e631e/netzwerk-config-IHRNAME.git
    cd netzwerk-config-IHRNAME
    dir
    ⚠️Self-Signed Zertifikat
    Das Lab-GitLab verwendet ein selbstsigniertes Zertifikat. Der Befehl git config --global http.sslVerify false ist nötig, damit Git die HTTPS-Verbindung akzeptiert.
✅ Erfolgskriterium: Sie haben ein neues Projekt in GitLab erstellt und es lokal geklont.

3. Projekte und Groups

GitLab organisiert Repositories in einer hierarchischen Struktur. Das ist besonders für größere Teams wichtig.

Die Hierarchie verstehen

198.18.133.100 (Instanz)
└── infrastructure (Group)
├── networking (Subgroup)
│ ├── datacenter-fabric (Projekt)
│ ├── campus-switches (Projekt)
│ └── firewall-rules (Projekt)
├── compute (Subgroup)
│ └── vmware-configs (Projekt)
└── shared-templates (Projekt in Group)

Warum Groups?

👥 Gemeinsame Berechtigungen

Rechte werden auf Group-Ebene vergeben und vererben sich auf alle Projekte.

📊 Übersicht

Alle Projekte eines Teams an einem Ort. Issues und MRs können gruppenübergreifend angezeigt werden.

🔄 Gemeinsame Runner

CI/CD Runner können auf Group-Ebene definiert werden und stehen allen Projekten zur Verfügung.

🏷️ Gemeinsame Labels

Labels, Milestones und Variablen können auf Group-Ebene definiert werden.

Zugriffsebenen (Roles)

RolleKann...Typische Nutzung
GuestIssues sehen, kommentierenStakeholder, Management
ReporterCode lesen, Issues erstellenQA, Support
DeveloperPush, MRs erstellen, BranchesEntwickler, Netzwerk-Ingenieure
Maintainer+ Protected Branches, MRs mergenTech Leads, Senior Engineers
OwnerVolle Kontrolle, Projekt löschenTeam-/Abteilungsleiter

4. Protected Branches

Protected Branches sind ein Sicherheitsmechanismus, der verhindert, dass kritische Branches (wie main oder production) versehentlich oder böswillig beschädigt werden.

⚠️Warum ist das wichtig?
Stellen Sie sich vor, jemand pusht versehentlich eine fehlerhafte Konfiguration direkt auf main – und die automatische Pipeline deployed sie sofort auf 500 Switches. Protected Branches verhindern genau das!

Was Protected Branches verhindern

🚫 Verboten

  • • Direkter Push auf den Branch
  • • Force Push (Überschreiben der History)
  • • Branch löschen
  • • Ungeprüfte Änderungen mergen

✅ Erlaubt

  • • Änderungen über Merge Requests
  • • Mit erforderlichen Approvals
  • • Nach erfolgreicher Pipeline
  • • Durch autorisierte Maintainer

Protected Branch Einstellungen

GitLab Protected Branches Einstellungen mit Berechtigungskonfiguration
🔍 Vergrößern
Protected Branches Settings – Hier legen Sie fest, wer auf welche Branches pushen darf
# Settings → Repository → Protected Branches
Branch:main
Allowed to merge:Maintainers
Allowed to push:No one
Require approval:1 approval required

Merge Request Approval Rules

Zusätzlich zu Protected Branches können Sie Approval Rules definieren:

  • Anzahl Approvals: Mindestens X Personen müssen zustimmen
  • Code Owners: Bestimmte Dateien brauchen Approval vom zuständigen Team
  • Eligible Approvers: Nur bestimmte Personen/Gruppen dürfen approven
  • Author kann nicht approven: Vier-Augen-Prinzip erzwingen
🔧🔧 Übung 2: README.md aktualisieren und committen (~8 Min)

Aktualisieren Sie die vorhandene README mit einer sinnvollen Projektbeschreibung.

  1. README.md bearbeiten:

    Die Datei README.md existiert bereits im Projektordnernetzwerk-config-IHRNAME (sie wurde beim Erstellen des Projekts mit angelegt). Öffnen Sie sie in VS Code und ersetzen Sie den Inhalt mit folgendem:

    📄 README.md
    # Netzwerk-Konfiguration
    
    Dieses Repository enthält die Netzwerkkonfiguration für unser VXLAN-Fabric.
    
    ## Struktur
    
    ```
    .
    ├── inventory/        # Geräte-Inventar
    ├── host_vars/        # Gerätespezifische Variablen
    ├── group_vars/       # Gruppenvariablen (Spines, Leafs)
    ├── templates/        # Jinja2-Templates
    └── playbooks/        # Ansible Playbooks
    ```
    
    ## Verwendung
    
    ```bash
    # Konfiguration validieren
    ansible-playbook playbooks/validate.yml
    
    # Konfiguration deployen (nur auf Staging)
    ansible-playbook playbooks/deploy.yml -l staging
    ```
    
    ## Kontakt
    
    Maintainer: IHR NAME
  2. Änderungen committen und pushen (in PowerShell):
    git status
    git add README.md
    git commit -m "docs: README mit Projektstruktur aktualisiert"
    git push origin master
  3. Alternative: Direkt in VS Code committen und pushen

    Sie können Änderungen auch direkt über die VS Code Source Control Sidebar committen, ohne das Terminal zu benutzen:

    1. Klicken Sie links auf das Source Control Icon (Branches-Symbol, oder Ctrl+Shift+G)
    2. Sie sehen die geänderten Dateien unter "Changes"
    3. Klicken Sie auf das + neben der Datei (oder "Stage All Changes"), um sie zu stagen
    4. Geben Sie eine Commit-Message im Textfeld oben ein
    5. Klicken Sie auf den "Commit" Button (✓ Häkchen)
    6. Klicken Sie auf "Sync Changes" oder die drei Punkte → Push, um zum Server zu pushen
    VS Code Source Control Sidebar: Geänderte Dateien stagen, Commit-Message eingeben, Commit Button klicken
    🔍 Vergrößern
    VS Code Source Control: Änderungen stagen, committen und pushen — alles ohne Terminal
  4. In GitLab prüfen: Öffnen Sie Ihr Projekt im Browser und verifizieren Sie, dass die README angezeigt wird.
✅ Erfolgskriterium: Ihre README.md wird auf der Projektseite in GitLab angezeigt.
🔧🔧 Übung 3: Branch Protection einrichten (~8 Min)

Schützen Sie Ihren main-Branch vor direkten Pushes.

  1. In GitLab navigieren:
    • Öffnen Sie Ihr Projekt
    • Gehen Sie zu Settings → Repository
    • Klappen Sie Protected branches auf
  2. Branch schützen:
    • Branch: main
    • Allowed to merge: Maintainers
    • Allowed to push and merge: No one
    • Klicken Sie Protect
  3. Testen Sie den Schutz (in PowerShell):
    # Versuchen Sie, direkt auf main zu pushen
    Add-Content -Path README.md -Value "# Test"
    git add .
    git commit -m "test: direkter push"
    git push origin main
    
    # Erwartetes Ergebnis: FEHLER!
    # remote: GitLab: You are not allowed to push code to protected branches
  4. Änderung rückgängig machen:
    git reset --hard HEAD~1
  5. Protected Branch wieder deaktivieren:

    Damit wir in den nächsten Übungen wieder direkt auf main pushen können, entfernen Sie den Branch-Schutz wieder:

    • Gehen Sie zu Settings → Repository → Protected branches
    • Klicken Sie bei main auf Unprotect
    • Bestätigen Sie die Aktion
⚠️Hinweis: Admin/Root-User
Da Sie als root-User (Administrator) eingeloggt sind, kann es sein, dass der Push trotzdem durchgeht – Admins können Protected Branch Regeln überschreiben. In einer Produktionsumgebung hätten normale Developer-Accounts keinen Admin-Zugriff und würden die Fehlermeldung sehen. Setzen Sie in diesem Fall die Änderung trotzdem mit git reset --hard HEAD~1 zurück, um den Workflow korrekt fortzusetzen.
✅ Erfolgskriterium: Sie verstehen, wie Protected Branches funktionieren. Als Admin-User wird der Push möglicherweise nicht blockiert – in einer realen Umgebung mit normalen Developer-Accounts würde die Fehlermeldung "not allowed to push to protected branches" erscheinen.

5. Der Merge Request Workflow im Detail

Ein Merge Request (MR) ist wie ein formeller Änderungsantrag. Statt Änderungen direkt einzuspielen, schlagen Sie sie vor – und Kollegen prüfen sie, bevor sie live gehen.

Die Phasen eines Merge Requests

1
Draft
2
Open
3
Review
4
Approved
5
Merged

Phase 1: Draft Merge Request

Ein Draft MR signalisiert: "Ich arbeite noch daran, bitte noch nicht reviewen!" – perfekt für Work-in-Progress.

# Feature-Branch erstellen und pushen
git checkout -b feature/add-vlan-100
New-Item -ItemType Directory -Force -Path vlans
Set-Content -Path vlans/vlan100.yaml -Value "vlan_id: 100`nname: Management"
git add .
git commit -m "feat: VLAN 100 für Management hinzugefügt"
git push -u origin feature/add-vlan-100

In GitLab:

  1. Klicken Sie auf Create merge request
  2. Wählen Sie "Mark as draft" (oder Titel beginnt mit "Draft:")
  3. Fügen Sie eine Beschreibung hinzu, was noch fehlt
💡Wann Draft verwenden?
  • Wenn Sie Feedback brauchen, bevor alles fertig ist
  • Wenn die Pipeline noch rot ist
  • Wenn Sie den MR für sich selbst als TODO tracken wollen
  • Wenn Sie mehrere Tage an einem Feature arbeiten
GitLab Merge Request erstellen Formular mit Titel und Beschreibung
🔍 Vergrößern
Einen neuen Merge Request erstellen – Titel, Beschreibung und Reviewer zuweisen

Phase 2: MR zur Review freigeben

Wenn Ihre Arbeit fertig ist, entfernen Sie den Draft-Status:

  • Klicken Sie auf "Mark as ready"
  • Weisen Sie einen Reviewer zu (Dropdown rechts)
  • Optional: Setzen Sie ein Label (z.B. "needs-review")

Phase 3: Code Review

Der Reviewer prüft Ihre Änderungen. In GitLab kann er:

GitLab Merge Request Diff-Ansicht mit Codeänderungen
🔍 Vergrößern
Die Diff-Ansicht zeigt alle Änderungen – grün für Hinzugefügtes, rot für Entferntes

💬 Kommentare

An einzelnen Zeilen Fragen stellen oder Verbesserungen vorschlagen.

💡 Suggestions

Konkrete Code-Änderungen vorschlagen, die der Author mit einem Klick übernehmen kann.

🧵 Threads

Diskussionen zu einzelnen Punkten. Müssen "resolved" werden, bevor gemergt wird.

✅ Approve

Formelle Zustimmung: "Ich habe geprüft, das kann gemergt werden."

Phase 4: Approval

Nachdem alle Kommentare bearbeitet und Threads resolved wurden, klickt der Reviewer auf "Approve". Je nach Konfiguration sind mehrere Approvals nötig.

Phase 5: Merge

Wenn alle Bedingungen erfüllt sind (Approvals, Pipeline grün, keine offenen Threads), kann der MR gemergt werden:

Merge-Optionen

  • Merge – Alle Commits werden übernommen (Standard)
  • Squash and merge – Alle Commits werden zu einem zusammengefasst
  • Delete source branch – Feature-Branch nach Merge löschen (empfohlen)
🔧🔧 Übung 4: Merge Request erstellen (~10 Min)

Erstellen Sie einen vollständigen Merge Request.

  1. Feature-Branch erstellen (in PowerShell):
    cd netzwerk-config-IHRNAME
    git checkout main
    git pull origin main
    git checkout -b feature/add-vlan-200
    
    # Ordner erstellen
    New-Item -ItemType Directory -Force -Path vlans

    Erstellen Sie in VS Code eine neue Datei vlans/vlan200.yaml mit folgendem Inhalt:

    📄 vlans/vlan200.yaml
    ---
    vlan:
      id: 200
      name: Clients
      description: "Client-Netzwerk für Arbeitsplätze"
      ip_range: "10.200.0.0/24"
      gateway: "10.200.0.1"
      dhcp_enabled: true

    Dann committen und pushen:

    git add .
    git commit -m "feat: VLAN 200 für Client-Netzwerk"
    git push -u origin feature/add-vlan-200
  2. In GitLab MR erstellen:
    • Klicken Sie auf den Link in der Push-Ausgabe ODER
    • Gehen Sie zu Merge requests → New merge request
    • Source: feature/add-vlan-200
    • Target: main
  3. MR ausfüllen:
    • Titel: "feat: VLAN 200 für Client-Netzwerk hinzufügen"
    • Beschreibung: Was, warum, wie testen?
    • Reviewer: Lassen Sie das Feld leer oder weisen Sie sich selbst zu (in der Praxis würden Sie hier einen Kollegen als Reviewer zuweisen)
⏳ Warten: Mergen Sie NOCH NICHT – das machen wir nach dem Code Review in Übung 6.

6. Code Review Best Practices

Code Reviews sind das Vier-Augen-Prinzip für Konfigurationen. Hier sind die wichtigsten Regeln für effektive Reviews.

Für den Author (Sie erstellen den MR)

✅ Do

  • • Kleine, fokussierte MRs (max. 200-400 Zeilen)
  • • Aussagekräftige Commit-Messages
  • • Gute Beschreibung: Was? Warum? Wie testen?
  • • Selbst-Review vor Zuweisung
  • • Screenshots/Logs bei UI/Output-Änderungen

❌ Don't

  • • Riesige MRs mit 20+ Dateien
  • • Mehrere unabhängige Features in einem MR
  • • Leere Beschreibung ("fixes stuff")
  • • Reviewer ohne Kontext zuweisen

Für den Reviewer (Sie prüfen den MR)

✅ Do

  • • Konstruktiv sein, nicht kritisieren
  • • Fragen stellen statt Befehle geben
  • • Positives Feedback geben ("Gute Lösung!")
  • • Suggestions statt nur Kommentare
  • • Zeitnah reviewen (<24h)

❌ Don't

  • • Persönlich werden
  • • Nur "LGTM" ohne echte Prüfung
  • • Stilfragen zum Blocker machen
  • • Wochen warten lassen

Was prüfen? Checkliste für Netzwerk-Konfigurationen

  • Syntax korrekt? (YAML, Jinja2, etc.)
  • Naming Conventions? (VLANs, Interfaces, etc.)
  • IP-Adressen/Ranges korrekt? (keine Überlappung)
  • Sicherheit? (keine Secrets im Code, ACLs korrekt)
  • Abhängigkeiten? (Reihenfolge, Referenzen)
  • Dokumentation? (Kommentare, README aktuell)
  • Tests? (Pipeline grün, Validierung erfolgreich)
GitLab Code Review mit Inline-Kommentaren und Suggestions
🔍 Vergrößern
Code Review in Aktion – Kommentare und Suggestions direkt an den Codezeilen

Kommentar-Konventionen

Verwenden Sie Präfixe, um die Wichtigkeit zu signalisieren:

PräfixBedeutungBeispiel
blocker:Muss gefixt werdenblocker: Diese IP ist bereits vergeben!
suggestion:Verbesserungsvorschlagsuggestion: VLAN-Name könnte sprechender sein
question:Frage/Klärungsbedarfquestion: Warum /24 statt /23?
nit:Kleinigkeit, kein Blockernit: Trailing whitespace
praise:Lob!praise: Sehr saubere Struktur! 👍
🔧🔧 Übung 5: Code Review durchführen (~15 Min)

Üben Sie den Code Review Workflow, indem Sie Ihren eigenen Merge Request reviewen. In der Praxis würde ein Kollege diesen Review durchführen – hier lernen Sie die Werkzeuge und Funktionen kennen.

  1. Ihren MR öffnen:
    • Gehen Sie zu Merge requests
    • Öffnen Sie Ihren MR aus Übung 4
    • Wechseln Sie zum Tab Changes
  2. Kommentare hinterlassen:
    • Klicken Sie auf eine Zeile, um einen Kommentar zu hinterlassen
    • Fügen Sie mindestens 3 Kommentare mit verschiedenen Präfixen hinzu:
    • question: Warum /24 statt /23 für das Client-Netzwerk?
    • nit: VLAN-Name könnte sprechender sein
    • praise: Saubere YAML-Struktur! 👍
  3. Suggestion erstellen:
    • Erstellen Sie einen neuen Kommentar an einer Codezeile
    • Klicken Sie auf das Suggestion-Icon (💡)
    • Schreiben Sie einen konkreten Änderungsvorschlag im Code-Block
    • Z.B. den VLAN-Namen von "Clients" zu "Client-Workstations" ändern
  4. Auf Kommentare reagieren und Threads resolven:
    • Antworten Sie auf Ihre eigenen Kommentare (z.B. "Guter Punkt, wird angepasst")
    • Bei der Suggestion: Klicken Sie Apply suggestion
    • Resolven Sie alle bearbeiteten Threads über den Resolve thread-Button
ℹ️Warum Self-Review?
In der Praxis ist ein Code Review immer ein Vier-Augen-Prinzip mit einem Kollegen. Hier üben Sie die GitLab-Funktionen (Kommentare, Suggestions, Threads), damit Sie sie im Arbeitsalltag sicher beherrschen.
✅ Erfolgskriterium: Sie haben Kommentare mit verschiedenen Präfixen erstellt, eine Suggestion angewendet und alle Threads resolved.
🔧🔧 Übung 6: Merge Request genehmigen und mergen (~8 Min)

Schließen Sie den Review-Prozess ab, indem Sie Ihren eigenen MR approven und mergen.

  1. Eigenen MR approven:
    • Öffnen Sie Ihren MR aus Übung 4
    • Stellen Sie sicher, dass alle Threads resolved sind
    • Klicken Sie auf Approve
    ℹ️Self-Approval im Workshop
    Als root/Admin-User können Sie Ihren eigenen MR approven. In einer Produktionsumgebung wäre dies durch Approval Rules unterbunden – dort muss ein anderer Kollege den MR genehmigen (Vier-Augen-Prinzip).
  2. MR mergen:
    • Klicken Sie auf Merge
    • Option: Delete source branch aktivieren
  3. Lokal aktualisieren (in PowerShell):
    git checkout main
    git pull origin main
    
    # Prüfen, dass die Änderungen da sind
    dir vlans/
    Get-Content vlans/vlan200.yaml
  4. In GitLab prüfen:
    • Der MR zeigt Status Merged
    • Der Feature-Branch wurde gelöscht
    • Die Datei vlans/vlan200.yaml ist auf main sichtbar
✅ Erfolgskriterium: Der MR ist gemergt, der Feature-Branch gelöscht und die Änderungen sind lokal und in GitLab auf main sichtbar.

7. GitLab Issues und Boards

Issues sind das Aufgaben-Management in GitLab. Sie tracken Bugs, Features, Tasks und alles, was erledigt werden muss.

Issue-Anatomie

#42VLAN 300 für Gäste-WLAN einrichten
Assignee:Max Mustermann
Milestone:Sprint 2024-Q1
Labels:featurepriority::high
Due date:2024-02-15

Issue-Templates

Templates sorgen für konsistente Issues. Erstellen Sie.gitlab/issue_templates/ in Ihrem Repo:

📄 .gitlab/issue_templates/Netzwerk-Änderung.md
## Beschreibung
<!-- Was soll geändert werden? -->

## Betroffene Geräte/VLANs
- [ ] Switches
- [ ] Router
- [ ] Firewalls
- [ ] VLANs: 

## Geplante Änderungen
```yaml
# Beispiel-Konfiguration
```

## Rollback-Plan
<!-- Wie wird zurückgerollt, falls etwas schief geht? -->

## Checkliste
- [ ] Change-Antrag genehmigt
- [ ] Staging getestet
- [ ] Maintenance-Window geplant
- [ ] Rollback-Plan dokumentiert

Issue Boards

Boards sind Kanban-Ansichten Ihrer Issues. Sie helfen, den Arbeitsfortschritt zu visualisieren.

GitLab Issue Board mit Kanban-Spalten für verschiedene Arbeitsphasen
🔍 Vergrößern
Issue Boards – Aufgaben visuell durch Phasen wie Open, In Progress und Done verfolgen
📋 Open
#45 DNS-Server migrieren
#48 Backup-Route prüfen
🔄 In Progress
#42 VLAN 300 einrichten
👀 Review
#39 Firewall-Regeln
✅ Done
#38 VLAN 100 deployed
#35 NTP konfiguriert

Issues mit Merge Requests verknüpfen

Verknüpfen Sie MRs mit Issues, um automatische Schließung zu ermöglichen:

# In der MR-Beschreibung oder Commit-Message:

Closes #42
Fixes #42
Resolves #42

# Mehrere Issues:
Closes #42, #43, #44

# Nur verknüpfen (nicht schließen):
Related to #42
🔧🔧 Übung 7: Issue erstellen und mit MR verknüpfen (~10 Min)

Erstellen Sie ein Issue und lösen Sie es mit einem Merge Request.

  1. Issue erstellen:
    • Gehen Sie zu Issues → New issue
    • Titel: "VLAN 300 für Gäste-WLAN einrichten"
    • Beschreibung:
      ## Anforderung
      Gäste-WLAN benötigt eigenes VLAN mit Internetzugang.
      
      ## Technische Details
      - VLAN ID: 300
      - Name: Guest-WiFi
      - IP-Range: 10.30.0.0/24
      - Gateway: 10.30.0.1
      
      ## Akzeptanzkriterien
      - [ ] VLAN konfiguriert
      - [ ] Gateway erreichbar
      - [ ] Internet-Zugang funktioniert
    • Label hinzufügen: feature
    • Merken Sie sich die Issue-Nummer (z.B. #1)
  2. Feature-Branch mit Issue-Referenz (in PowerShell):
    git checkout main
    git pull origin main
    git checkout -b feature/issue-1-vlan-300

    Erstellen Sie in VS Code eine neue Datei vlans/vlan300.yaml:

    📄 vlans/vlan300.yaml
    ---
    vlan:
      id: 300
      name: Guest-WiFi
      description: "Gäste-WLAN mit Internet-Zugang"
      ip_range: "10.30.0.0/24"
      gateway: "10.30.0.1"
      dhcp_enabled: true
      internet_access: true
      internal_access: false

    Dann committen und pushen:

    git add .
    git commit -m "feat: VLAN 300 für Gäste-WLAN
    
    Closes #1"
    git push -u origin feature/issue-1-vlan-300
  3. MR erstellen:
    • In der Beschreibung: Closes #1
    • Prüfen Sie, dass das Issue verknüpft angezeigt wird
  4. MR mergen und Issue prüfen:
    • Nach dem Merge: Öffnen Sie das Issue
    • Es sollte automatisch geschlossen sein!
✅ Erfolgskriterium: Das Issue wurde automatisch geschlossen, als der MR gemergt wurde.

8. CI/CD Pipeline Grundlagen

Eine Pipeline ist wie ein Fließband in einer Fabrik: Bei jedem neuen Commit läuft automatisch eine Reihe von Schritten ab – testen, validieren, deployen.

ℹ️📌 Hinweis
CI/CD wird in Modul 5 ausführlich behandelt. Hier lernen Sie nur die Grundlagen, um Pipelines in GitLab zu verstehen.

Was bedeutet CI/CD?

CI – Continuous Integration

Bei jedem Push werden automatisch Tests ausgeführt. Fehler werden sofort erkannt, nicht erst bei der Produktion.

CD – Continuous Delivery/Deployment

Änderungen werden automatisch in Staging/Produktion deployed. Entweder manuell freigegeben (Delivery) oder vollautomatisch (Deployment).

Runner einem Projekt zuordnen

⚠️🏃 Runner müssen dem Projekt zugewiesen werden!
Bevor eine Pipeline laufen kann, muss Ihr Projekt Zugriff auf mindestens einen Runner haben. Runner sind nicht automatisch für alle Projekte verfügbar!
  1. Navigieren Sie zu Settings → CI/CD → Runners
  2. Unter "Available specific runners" sehen Sie die verfügbaren Runner
  3. Klicken Sie auf "Enable for this project" für jeden Runner
Im Lab stehen zwei Runner zur Verfügung:
  • Shell Runner (Tag: shell) — führt Jobs direkt auf dem Server aus
  • Docker Runner (Tag: docker) — führt Jobs in Docker-Containern aus (für Jobs mit image:)

Eine einfache Pipeline

📄 .gitlab-ci.yml
# GitLab CI/CD Pipeline für Netzwerk-Konfiguration
stages:
  - validate      # Stufe 1: Prüfen
  - test          # Stufe 2: Testen
  - deploy        # Stufe 3: Deployen

# Job 1: YAML-Syntax prüfen
validate-yaml:
  stage: validate
  image: python:3.11-slim
  tags: [docker]
  before_script:
    - pip install yamllint
  script:
    - echo "🔍 Prüfe YAML-Syntax..."
    - yamllint vlans/
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_COMMIT_BRANCH == "main"

# Job 2: Konfiguration gegen Schema validieren
validate-schema:
  stage: validate
  image: python:3.11-slim
  tags: [docker]
  before_script:
    - pip install jsonschema pyyaml
  script:
    - echo "📋 Prüfe gegen Schema..."
    - python scripts/validate_schema.py
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"

# Job 3: Auf Staging deployen (nur bei MR)
deploy-staging:
  stage: deploy
  tags: [shell]
  script:
    - echo "🚀 Deploye auf Staging..."
    - ansible-playbook -i staging playbooks/deploy.yml
  environment:
    name: staging
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
  when: manual  # Manueller Klick erforderlich

# Job 4: Auf Produktion deployen (nur main)
deploy-production:
  stage: deploy
  tags: [shell]
  script:
    - echo "🚀 Deploye auf Produktion..."
    - ansible-playbook -i production playbooks/deploy.yml
  environment:
    name: production
  rules:
    - if: $CI_COMMIT_BRANCH == "main"
  when: manual  # Sicherheit: Manueller Klick
  needs:
    - validate-yaml

Pipeline-Konzepte

KonzeptBeschreibung
StagesPhasen der Pipeline (laufen nacheinander)
JobsEinzelne Aufgaben (laufen parallel innerhalb einer Stage)
RunnerDie Maschine/Container, die Jobs ausführt
TagsLabels die bestimmen, welcher Runner einen Job ausführt (z.B. shell, docker)
ArtifactsDateien, die zwischen Jobs weitergegeben werden
VariablesUmgebungsvariablen (Secrets, Konfiguration)
RulesBedingungen, wann ein Job läuft

Pipeline-Status im MR

Im Merge Request sehen Sie den Pipeline-Status:

GitLab Pipeline mit grünem Status und erfolgreichen Jobs
🔍 Vergrößern
Eine erfolgreiche Pipeline – alle Stages grün, bereit zum Merge
🔀Merge Request !15
Pipeline passed
✅ validate-yaml✅ validate-schema⏸️ deploy-staging (manual)
💡Pipelines blockieren Merges
Sie können konfigurieren, dass MRs nur gemergt werden können, wenn die Pipeline grün ist. Das verhindert, dass fehlerhafte Konfigurationen in main landen.

Settings → Merge requests → Merge checks:
✅ "Pipelines must succeed"

❓ Quiz: Testen Sie Ihr GitLab-Wissen (5 Min)

Versuchen Sie, die Fragen ohne Zurückblättern zu beantworten.

1. Was ist der Unterschied zwischen Git und GitLab?

Antwort anzeigen

Git ist das Versionskontrollsystem (Kommandozeile, lokal).GitLab ist eine Web-Plattform, die Git um Funktionen wie Merge Requests, CI/CD-Pipelines, Issue Tracking und eine Container Registry erweitert.

2. Was bewirkt ein Protected Branch?

Antwort anzeigen

Ein Protected Branch verhindert, dass Entwickler direkt auf diesen Branch pushen oder ihn löschen können. Änderungen müssen über Merge Requests eingereicht und von berechtigten Personen geprüft und gemerged werden.

3. Was ist ein Merge Request und warum ist er wichtig?

Antwort anzeigen

Ein Merge Request ist ein formeller Änderungsantrag. Er zeigt alle Änderungen eines Feature-Branches an und ermöglicht Code Review durch Kollegen. Erst nach Genehmigung werden die Änderungen in den Hauptbranch gemerged. Das ist das 4-Augen-Prinzip für Code.

4. Beschreiben Sie den typischen GitLab-Workflow in 4 Schritten.

Antwort anzeigen

1. Branch erstellen (git checkout -b feature/mein-feature)
2. Änderungen committen und pushen (git push origin feature/mein-feature)
3. Merge Request erstellen in GitLab (mit Beschreibung und Reviewer)
4. Review und Merge — Kollege prüft, gibt Approval, MR wird gemerged

5. Was ist die GitLab Container Registry und wofür brauchen wir sie?

Antwort anzeigen

Die Container Registry ist ein privater Speicher für Docker-Images direkt in GitLab. CI/CD-Pipelines können dort Images ablegen und für spätere Jobs wieder herunterladen. So bleiben die Images nahe am Code und unter Ihrer Kontrolle.

Zusammenfassung

✅ Das haben Sie gelernt

  • ☑️ GitLab-Oberfläche navigieren
  • ☑️ Projekte und Groups verstehen
  • ☑️ Protected Branches einrichten
  • ☑️ Merge Requests erstellen
  • ☑️ Code Reviews durchführen
  • ☑️ Issues und Boards nutzen
  • ☑️ Issues mit MRs verknüpfen
  • ☑️ CI/CD Pipelines verstehen

🔑 Key Takeaways

  • Merge Requests = Kontrollierte Änderungen mit Review
  • Protected Branches = Sicherheitsnetz für kritische Branches
  • Code Reviews = Qualitätssicherung durch Vier-Augen-Prinzip
  • CI/CD = Automatisierte Validierung und Deployment
  • Issues = Strukturierte Aufgabenverwaltung

📋 GitLab Cheat Sheet

# SSL-Verifikation deaktivieren (self-signed Zertifikat)
git config --global http.sslVerify false

# Projekt klonen
git clone https://198.18.133.100/group/project.git

# Feature-Branch erstellen
git checkout -b feature/mein-feature
git push -u origin feature/mein-feature

# Nach Änderungen
git add .
git commit -m "feat: Beschreibung der Änderung"
git push

# Branch aktualisieren mit main
git checkout main
git pull origin main
git checkout feature/mein-feature
git merge main  # oder: git rebase main