Day-0 | Course Overview & Syllabus | 30 Days Of GitLab DevOps

Welcome to the advanced 30 Days of GitLab DevOps series, hosted by Aditya Jaiswal. This course provides an exhaustive, end-to-end exploration of GitLab, moving far beyond simple YAML file creation to cover comprehensive enterprise-grade platform engineering, built-in security, container registries, Kubernetes integrations, and advanced administration.

1. Why GitLab? The All-In-One Platform Philosophy

When embarking on a DevOps engineering journey, choosing the right platform foundation is critical. While tools like GitHub Actions rely on an ecosystem-based model requiring numerous third-party integrations, GitLab is engineered as a single integrated DevOps platform.

Real-Life Analogy: The Automated Factory vs. The Hardware Store

Think of GitHub Actions like visiting a massive hardware store where you must buy individual wrenches, screws, electrical wiring, and safety alarms from different aisles, then figure out how to wire them together yourself. In contrast, GitLab is like a fully automated pre-assembled factory assembly line—the welding robots, conveyor belts, security scanners, paint booths, and central control rooms are already built into the building blueprint and wired together out of the box.

2. GitLab vs. GitHub: Feature-by-Feature Comparison

To understand why enterprise organizations heavily prefer GitLab while startups often favor GitHub's modular flexibility, consider the following technical breakdown:

Feature / Domain	GitLab (Single Platform Approach)	GitHub (Ecosystem / Modular Approach)
Platform Philosophy	Single integrated DevOps platform (All-in-One)	Ecosystem-based (Integrate as per requirement)
Project Planning & Tracking	Built-in Issues Boards, Roadmaps & Agile planning	GitHub Projects (Basic version; often needs Jira)
Source Code Management	Core Git repository management	Core Git repository management
CI/CD Orchestration	Native `.gitlab-ci.yml` pipelines	GitHub Actions (Pre-built workflows)
Security Scanning	Built-in SAST, DAST, & Dependency scanning	Requires external tools and manual setup
Container Registry	Built-in per-project container registry	Available as a separate service to integrate
Artifact & Package Management	Built-in package registry	GitHub Packages (Separate service integration)
Kubernetes Deployments	Native Kubernetes Agents & Auto DevOps	Requires Argo CD, Terraform, or external tools
Monitoring Integration	Default Prometheus integration included	Requires external tools like Grafana or DataDog
Configuration Complexity	Unified `.gitlab-ci.yml` file	Multiple tools and fragmented configurations
Setup Effort & Cost	Low setup effort; reduces overall tooling cost	Higher setup effort; requires gluing tools together
Organizational Preference	Highly preferred in enterprise organizations	Preferred in startups and flexible architectures

3. The 30-Day Course Architecture & Weekly Roadmap

This course spans 31 total videos across 4 structured weeks, concluding with a comprehensive capstone project.

Structure & Concept Flow

Day-0: Course Overview & Syllabus

+-- Week 1: Platform Foundation (Architecture, SCM, Issues, Registry)

+-- Week 2: CI/CD Architecture & Pipelines (Runners, DAG, Artifacts, Debugging)

+-- Week 3: Docker Security & Kubernetes (SAST, Kaniko, Vault, Agent K, DAST)

+-- Week 4: Advanced Admin & Hardening (Parent-Child, Blue/Green, DORA, Hardening)

+-- Capstone Project: End-to-End Enterprise Deployment

4. Week 1: Platform Foundation & Repository Mastery

The first week focuses entirely on understanding the core platform architecture and establishing rigorous source control workflows before writing any deployment pipelines.

GitLab Internal Architecture: Deep dive into Rails backend, Gitaly (Git storage daemon), Redis (caching/queuing), Sidekiq (background job processor), and PostgreSQL (relational database).
Code Review & Collaboration: Managing merge requests (MRs), code review best practices, and collaborative feedback loops.
Hierarchical Structures: Organizing projects, groups, and subgroups effectively to manage enterprise permissions and visibility.
Agile Project Management: Utilizing built-in issues, Kanban boards, and roadmaps to track task progress without external tools like Jira.
Git Workflows & Branch Protection: Comparing GitFlow vs. Trunk-Based development and configuring strict branch protection rules.
Container & Package Registries: Utilizing built-in project registries for storing Docker images and software packages.

5. Week 2: CI/CD Architecture & Pipeline Fundamentals

Week 2 introduces the mechanics of GitLab CI/CD, transitioning from simple jobs to complex, optimized execution graphs.

Pipeline Architecture: Understanding executor types, the CI lint tool, and the coordinator-runner model.
GitLab Runners: Installing, registering, and configuring Linux Virtual Machines as runners alongside leveraging shared runners.
Pipeline Execution Control: Structuring stages, jobs, Directed Acyclic Graphs (DAG), and utilizing the needs keyword for parallel execution.
Variables & Secret Management: Injecting environment variables securely and masking sensitive credentials.
Artifacts & Caching: Passing intermediate build outputs between stages and caching dependencies to speed up builds.
Conditional Pipelines: Writing advanced logic using rules, workflow:rules, and conditional execution paths.
Debugging & Optimization: Identifying pipeline failures, reading logs, and optimizing execution speed.

6. Week 3: Docker Security & Kubernetes Integration

Week 3 bridges the gap between source code, security vulnerability scanning, and cloud-native deployments onto Kubernetes clusters.

Static Security Testing: Implementing Static Application Security Testing (SAST) and secret detection scans to catch vulnerabilities early.
Container Image Building: Comparing Docker-in-Docker (DinD) with Kaniko (building container images inside unprivileged pods without a Docker daemon).
Vulnerability Scanning: Scanning container images for Common Vulnerabilities and Exposures (CVEs) using Trivy.
Secrets Management: Integrating external secret managers like HashiCorp Vault.
Kubernetes Deployments: Managing kubectl, Helm charts, kubeconfig securely, and tracking rollout statuses.
GitLab Kubernetes Agent (agentk): Establishing secure, cluster-native communication for GitOps workflows.
Dynamic Application Security Testing (DAST): Scanning running applications for live vulnerabilities using OWASP ZAP.
Multi-Environment Promotion: Deploying systematically across lower environments through to production with manual approvals.

7. Week 4: Advanced Administration, Hardening & Capstone

The final week covers enterprise-grade pipeline patterns, operational metrics, server administration, and the final capstone project.

Review Apps & Dynamic Environments: Spawning temporary ephemeral environments for every pull request/merge request.
Multi-Project Pipelines: Orchestrating parent-child and multi-project pipeline triggers for decoupled microservices.
Advanced Deployment Strategies: Implementing zero-downtime deployments using Blue/Green and Canary rollout patterns.
Observability & Metrics: Tracking DevOps performance using DORA metrics and configuring real-time Slack notifications.
GitLab Self-Managed Administration: Managing GitLab instances, Role-Based Access Control (RBAC), and runner security hardening.
Capstone Project: Building and executing a fully reusable, end-to-end enterprise CI/CD pipeline featuring multi-stage deployments, security scans, automated notifications, and monitoring.

8. Course Execution Rules & Student Assignment Workflow

To get the maximum value out of this 30-day program, strict adherence to a daily implementation routine is required:

Structure & Concept Flow

Watch Daily Video -> Implement Code Same Day -> Update Discord Server -> Post Proof of Work on LinkedIn (Tag Instructor)

Zero Procrastination: Watch and implement each daily video on the day it is released. Do not backlog videos.
Active Communication: Join the official Discord server to share progress, ask questions, and report roadblocks.
Proof of Work (LinkedIn Assignment):
- After successfully implementing each day's task, publish a post on LinkedIn detailing what you built.
- Tag instructor Aditya Jaiswal to increase reach and visibility.
- Why? Recruiters rarely review raw GitHub repositories line-by-line. Consistent LinkedIn posts serve as a live, verified technical resume, making you stand out to industry recruiters.
Incentive: The top 3 most consistent students who complete all daily implementations and the capstone project will receive a surprise gift at the conclusion of the series.

9. Prerequisites for Success

Before diving into Day 1, ensure you meet the following prerequisites:

Git Fundamentals: Basic knowledge of version control operations (git push, branching, committing).
Linux Command Line: Familiarity with navigating the terminal and connecting to remote Linux Virtual Machines via SSH.
Docker Basics: Understanding container concepts and basic Docker CLI commands.
Kubernetes Basics: Familiarity with fundamental Kubernetes resources, specifically Pods and Deployments.
GitLab Account: An active, free account on gitlab.com.

Summary and Key Takeaways

Comprehensive Platform: GitLab is chosen for its all-in-one ecosystem, eliminating the need to glue together external tools for project management, CI/CD, security, and container registries.
Enterprise Standard: GitLab is heavily favored in enterprise environments for reducing setup effort and security fragmentation, whereas GitHub remains popular in agile startups.
31-Day Structured Journey: The syllabus is meticulously divided across 4 distinct weeks covering platform foundations, CI/CD pipelines, security/Kubernetes, and advanced administration.
Zero Backlog Policy: Students must implement lessons on the exact same day they are released to maintain learning momentum.
Proof of Work: Daily implementation assignments must be posted on LinkedIn as a verifiable technical resume to attract recruiter attention.
Community Support: Active engagement on the course Discord server ensures real-time troubleshooting and peer collaboration.
Capstone Integration: The course culminates in an enterprise-grade Capstone Project uniting every concept learned across the 30 days.
100% Free & Open: The entire advanced series is completely free and accessible to freshers, DevOps engineers, and SRE professionals alike.