·DevOps
Module 12: Course Conclusion and Certification
You are a Git Master. Summarize your journey from 'git init' to 'reflog' and discover the advanced resources and career paths that await a version control expert.
DevOps
195 articles
·DevOps
Module 12 Capstone Part 3: Release and Emergency Fixes
Handle the pressure. In Part 3 of the Capstone, you will create an official release tag and then practice a high-stakes disaster recovery using the git reflog.
·DevOps
Module 12 Capstone Part 2: Feature Development and Review
Build the feature. In Part 2 of the Capstone, you will practice the Feature Branch Workflow, use interactive rebase to polish your history, and simulate a professional code review loop.
·DevOps
Module 12 Capstone Part 1: Architecture and Setup
The Final Test begins. In this Capstone Project, you will build a complex multi-repo system from scratch. Part 1 covers repository architecture, organization, and submodule integration.
·DevOps
Module 11 Project C: Troubleshooting a 'Broken' Repository
Emergency room for Git. Learn how to fix the most common 'Broken' states, from detached HEADs and locked indexes to messy rebases and accidental large file commits.
·DevOps
Module 11 Project B: CI/CD with Git
From Git to Live. Learn how Git acts as the heartbeat of modern automation. Understand how a 'git push' triggers complex pipelines that build, test, and deploy your software automatically.
·DevOps
Module 11 Project A: Open Source Contribution Workflow
Join the global community. Follow this step-by-step project to master the 'Fork and Pull' model—the standard way that millions of developers contribute to open-source software on platforms like GitHub.
·DevOps
Module 10 Lesson 4: Git hooks: Automating your local environment
Let Git do the work for you. Learn how to use Git Hooks—local scripts that trigger automatically before a commit or push—to catch bugs, run tests, and format your code.
·DevOps
Module 10 Lesson 3: The git reflog for disaster recovery
Nothing is ever truly lost. Master the 'git reflog'—the secret diary that tracks every move you make in Git, allowing you to recover 'deleted' branches and abandoned commits.
·DevOps
Module 10 Lesson 2: Search and Interactive staging
Find and filter like a pro. Learn how to use 'git grep' to search your codebase instantly and master 'git add --interactive' for the ultimate control over your workspace.
·DevOps
Module 10 Lesson 1: Using aliases for speed
Stop typing long commands. Learn how to create custom Git aliases to turn complex commands into short, 2-character shortcuts that save you hours of typing every month.
·DevOps
Module 9 Lesson 4: Handling feedback and requested changes
Navigate the feedback loop. Learn how to update your Pull Request after a reviewer asks for changes, and how to communicate your fixes effectively.
·DevOps
Module 9 Lesson 3: The 'Squash and Merge' vs 'Merge Commit' debate
How should your history look? Explore the pros and cons of 'Squash and Merge' vs 'Create a Merge Commit', and learn how to choose the right strategy for your team.
·DevOps
Module 9 Lesson 2: Code review etiquette
Review like a human. Master the art of the code review—how to give constructive, empathetic feedback as a reviewer, and how to receive technical criticism as an author.
·DevOps
Module 9 Lesson 1: Writing professional Pull Requests
Sell your code. Learn how to write Pull Requests (PRs) that are easy to review, provide clear context, and help your team merge your work faster with less friction.
·DevOps
Module 8 Lesson 5: Trunk-Based Development
The peak of velocity. Learn Trunk-Based Development—the workflow used by the world's most elite engineering teams to deploy code hundreds of times per day.
·DevOps
Module 8 Lesson 4: GitHub Flow
Simple, fast, and agile. Learn GitHub Flow—the preferred workflow for modern web applications and teams that practice continuous delivery.
·DevOps
Module 8 Lesson 3: Git Flow
Master the classic enterprise workflow. Learn Git Flow—a highly structured branching strategy designed for projects with scheduled release cycles and multiple versions in the wild.
·DevOps
Module 8 Lesson 2: Feature Branch Workflow
The industry standard. Learn the Feature Branch Workflow—how to keep your 'main' branch stable by doing all your work in isolated feature branches and using Pull Requests for reviews.
·DevOps
Module 8 Lesson 1: Centralized Workflow
Start simple. Learn the Centralized Workflow—the most basic way for teams to collaborate, where everyone works on 'main' and manages conflicts as they arise.
·DevOps
Module 7 Lesson 5: Removing submodules
Cleanup your architecture. Learn the surprisingly manual process of removing a submodule, including updating the .gitmodules file and cleaning up Git's internal index.
·DevOps
Module 7 Lesson 4: Updating and synchronizing submodules
Stay up to date. Learn how to pull the latest changes from a submodule's remote and how to synchronize your parent project when a teammate updates a submodule's version.
·DevOps
Module 7 Lesson 3: Cloning repositories with submodules
Why is the folder empty? Learn how to correctly clone a project that uses submodules, and understand the difference between recursive clones and manual initialization.
·DevOps
Module 7 Lesson 2: Adding submodules to a repository
Start building your architecture. Learn the 'git submodule add' command and understand how the .gitmodules file tracks your external dependencies.
·DevOps
Module 7 Lesson 1: What are submodules and why use them
Master project architecture. Learn how Git Submodules allow you to keep one repository as a subdirectory of another while maintaining independent version control histories.
·DevOps
Module 6 Lesson 5: Tagging and releases
Mark your milestones. Learn how to use 'git tag' to label specific points in history as important releases, and discover the difference between lightweight and annotated tags.
·DevOps
Module 6 Lesson 4: Interactive rebase
Master the 'Refactor' for your history. Learn how to use 'git rebase -i' to squash commits, reorder history, and edit old commit messages to make your project look perfect.
·DevOps
Module 6 Lesson 3: Cherry-picking commits
Precision version control. Learn how to 'cherry-pick' a single commit from any branch and apply it to yours—perfect for grabbing a hotfix without the rest of a feature's changes.
·DevOps
Module 6 Lesson 2: Git rebase: linearizing history
Keep your history clean. Learn how 'git rebase' differs from 'git merge', and discover how to use it to create a perfectly linear project timeline that's easy to read.
·DevOps
Module 6 Lesson 1: Git stash: saving and restoring work in progress
Pause your work without committing. Learn how to use 'git stash' to temporarily set aside your changes so you can switch branches and fix urgent bugs without losing your progress.
·DevOps
Module 5 Lesson 5: Deleting remote branches
Keep the server clean. Learn the commands for deleting branches on the remote server and how to 'prune' your local repo to remove stale references to deleted branches.
·DevOps
Module 5 Lesson 4: Tracking remote branches
Understand the link between local and remote. Learn how 'Upstream Tracking' simplifies your workflow and how to manage branches that live in both worlds.
·DevOps
Module 5 Lesson 3: Fetch vs pull
Look before you leap. Learn the difference between 'git pull' and 'git fetch', and discover the professional workflow for inspecting remote changes before merging them.
·DevOps
Module 5 Lesson 2: Pushing and pulling changes
Sync your work with the world. Master the 'git push' and 'git pull' commands to upload your local commits and download the latest changes from your teammates.
·DevOps
Module 5 Lesson 1: Adding and removing remotes
Connect your local machine to the cloud. Learn how to manage 'Remotes'—the links that allow your repository to talk to GitHub, GitLab, or your team's private servers.
·DevOps
Module 4 Lesson 5: Handling merge conflicts
Don't panic! Learn why merge conflicts happen, how to read Git's conflict markers, and the step-by-step process for resolving them manually.
·DevOps
Module 4 Lesson 4: Fast-forward vs three-way merges
Not all merges are the same. Learn the difference between a simple 'Fast-Forward' and the more complex 'Merge Commit' (Three-Way Merge) and when to use each.
·DevOps
Module 4 Lesson 3: Merging branches
Bring the team together. Learn how to merge a feature branch back into 'main' and understand the basic workflow for combining disconnected histories.
·DevOps
Module 4 Lesson 2: Creating and switching branches
Master the mechanics of branch management. Learn how to create new branches, navigate between them, and understand 'HEAD'—the pointer that tells Git where you are.
·DevOps
Module 4 Lesson 1: Branch basics and naming conventions
Branching is Git's 'superpower.' Learn how branches allow you to work on multiple features in parallel without breaking your main project, and discover professional naming standards.
·DevOps
Module 3 Lesson 5: Diffing changes
See exactly what changed. Master 'git diff' to compare your working folder against the staging area, and your staging area against your latest commit.
·DevOps
Module 3 Lesson 4: Undoing changes
Everyone makes mistakes. Learn the three levels of 'Undo' in Git—from discarding unstaged edits to rolling back the entire repository history.
·DevOps
Module 3 Lesson 3: Viewing history with git log
Travel through time. Learn how to use 'git log' to explore your project's history, filter commits by author or date, and visualize the tree of changes.
·DevOps
Module 3 Lesson 2: Committing changes with git commit
Seal the snapshot. Learn how to record your staged changes into history, write professional commit messages, and follow the 'Atomic Commit' philosophy.
·DevOps
Module 3 Lesson 1: Staging changes with git add
Master the art of the Staging Area. Learn the different ways to use 'git add'—from staging individual files to interactive patching.
·DevOps
Module 2 Lesson 4: .gitignore and ignoring files
Not every file belongs in history. Learn how to use .gitignore to keep temporary files, sensitive secrets, and heavy dependencies out of your repository.
·DevOps
Module 2 Lesson 3: Repository structure (.git folder)
Demystify the 'Brain' of Git. Explore the contents of the hidden .git directory—from the object database to the config file—and learn how Git stores your history.
·DevOps
Module 2 Lesson 2: Cloning existing repositories
Don't reinvent the wheel. Learn how to download a full copy of a project—including its entire history—from platforms like GitHub using 'git clone'.
·DevOps
Module 2 Lesson 1: Initializing a repository
Turn any folder on your computer into a Git repository. Learn when and how to use 'git init' to start tracking your project's history.
·DevOps
Module 1 Lesson 4: Installing and configuring Git
Get Git up and running on your machine. We cover installation for all OSs and the essential configuration steps to identify yourself to Git.
·DevOps
Module 1 Lesson 3: Git architecture: working directory, staging area, repository
Understand the 'Three Trees' of Git. Learn how your files move from your folder to the 'Index' and finally into the 'Git Repository' history.
·DevOps
Module 1 Lesson 2: Git vs other version control systems
Why did Git win the version control wars? We compare Centralized (CVCS) vs. Distributed (DVCS) systems and explore the advantages of the modern approach.
·DevOps
Module 1 Lesson 1: What is Git and why use version control
Discover the foundations of version control. Learn how Git helps you track changes, collaborate, and travel back in time through your code's history.
·DevOps
Module 1 Lesson 1: What is a Container?
Start your container journey here. Learn the fundamental concept of a container, why it's different from a simple 'folder', and how it solves the 'it works on my machine' problem.
·DevOps
Module 1 Lesson 2: Containers vs. Virtual Machines
Is it a ship or a submarine? Understand the architectural differences between Containers and Virtual Machines (VMs), and why containers changed the world of cloud computing.
·DevOps
Module 1 Lesson 3: Why Containers Matter
Microservices, CI/CD, and the Cloud. Learn how containers enable the modern 'Agile' world where software is updated 100 times a day without breaking.
·DevOps
Module 1 Lesson 4: Portability, Isolation, and Scalability
Master the 'Three Pillars' of containerization. Discover how Docker provides consistent environments, security boundaries, and near-infinite scaling for your applications.
·DevOps
Module 1 Lesson 5: Introduction to Docker and Podman
Meet the giants of the container world. Learn about the Docker ecosystem and why Podman is becoming a popular 'Rootless' and 'Daemonless' alternative of choice.
·DevOps
Module 10 Lesson 1: Network Drivers in Depth
Go beyond the defaults. Explore the 5 major Docker network drivers—Bridge, Host, Null, Overlay, and Macvlan—and learn when to use each for specific architectural needs.
·DevOps
Module 10 Lesson 2: External Access and Port Mapping
Bridge the gap between your container and the world. Learn the intricacies of port publishing, IP binding, and how to troubleshoot connectivity issues from outside the host.
·DevOps
Module 10 Lesson 3: DNS and Service Discovery
Stop using IP addresses. Master Docker's internal DNS system to allow your containers to find and talk to each other using simple human-readable names.
·DevOps
Module 10 Lesson 4: Load Balancing with Nginx
Handle the traffic spike. Learn how to use an Nginx container as a 'Reverse Proxy' to distribute incoming requests across multiple app containers.
·DevOps
Module 10 Lesson 5: Securing Container Comms
Master the 'Zero Trust' model for containers. Learn how to encrypt inter-container traffic and use network policies to prevent unauthorized lateral movement.
·DevOps
Module 11 Lesson 1: Docker Registries
Where images live. Explore the major Docker registries like Docker Hub, GitHub Container Registry (GHCR), and AWS ECR to choose the right library for your images.
·DevOps
Module 11 Lesson 2: Pushing and Pulling Images
Master the image transition. Learn how to log in to various services, tag your images for specific registries, and 'Push' your code to the cloud.
·DevOps
Module 11 Lesson 3: CI/CD Integration with Docker
Automate everything. Learn how to use Docker in your GitHub Actions or GitLab CI pipelines to build, test, and push images automatically on every commit.
·DevOps
Module 11 Lesson 4: Automated Testing with Docker
Verify your code in a clean environment. Learn how to use Docker to run unit and integration tests as part of your automated build process.
·DevOps
Module 11 Lesson 5: Image Lifecycle Management
Keep your registry clean. Learn about image retention policies, cleaning up old tags, and why ignoring image bloat will eventually crash your cloud budget.
·DevOps
Module 12 Lesson 1: What is Orchestration?
From one to a thousand. Learn the core concepts of container orchestration: why it's needed for high availability, self-healing, and automated scaling.
·DevOps
Module 12 Lesson 2: Introduction to Docker Swarm
Orchestration without the headache. Learn how to turn multiple Docker hosts into a single cluster using Docker Swarm Mode.
·DevOps
Module 12 Lesson 3: Services and Stacks
Master the administrative units of Swarm. Learn how to define 'Services' for individual apps and 'Stacks' for entire multi-container architectures.
·DevOps
Module 12 Lesson 4: Introduction to Kubernetes
Meet the industry standard. Discover the architecture of Kubernetes, the difference between Pods and Containers, and why it is the OS of the modern cloud.
·DevOps
Module 12 Lesson 5: Swarm vs. Kubernetes
End the debate. Side-by-side comparison of Docker Swarm and Kubernetes to help you choose the right tool for your team's size, budget, and expertise.
·DevOps
Module 13 Lesson 1: Common Docker Errors
Demystify the red text. Learn how to diagnose and fix the the top 5 most common errors beginners and pros face when working with Docker.
·DevOps
Module 13 Lesson 2: Container Performance
Is your app slow or is it Docker? Learn how to monitor CPU, RAM, and I/O performance of your containers using the built-in 'stats' command and external tools.
·DevOps
Module 13 Lesson 3: System Maintenance
Reclaim your disk space. Master the art of Docker housekeeping, from pruning dangling images to managing large log files that eat your server's storage.
·DevOps
Module 13 Lesson 4: Production Security Checklist
The final audit. A comprehensive checklist of 10 essential security steps to take before deploying your Dockerized application to the public internet.
·DevOps
Module 13 Lesson 5: The Future of Containers
What's next? Explore the evolving landscape of container technology, from WebAssembly (WASM) and Serverless containers to the rise of 'Rootless' engines like Podman.
·DevOps
Module 14 Lesson 1: Dockerizing a Node.js Full-Stack App
From code to container. A step-by-step guide to containerizing a modern Node.js application with a React frontend, Express backend, and MongoDB database.
·DevOps
Module 14 Lesson 2: Project: Python AI/ML Workspace
Handle the heavy lifting. Learn how to containerize a Python Data Science environment with Jupyter Notebooks, Pandas, and GPU support.
·DevOps
Module 14 Lesson 3: Project: Legacy PHP/MySQL App
Bring the past into the future. Learn how to wrap an old PHP application and a MySQL database into containers, providing safety and portability to legacy code.
·DevOps
Module 14 Lesson 4: Project: Multi-Service Architecture
The microservices puzzle. Learn how to orchestrate a complex system with a Gateway, separate Services for Auth and Data, and a shared Message Queue.
·DevOps
Module 14 Lesson 5: Project: Static Site with Nginx
The speed king. Learn how to wrap a simple HTML/CSS/JS site or a modern SPA into an Nginx container for maximum performance and easy deployment.
·DevOps
Module 15 Lesson 1: Capstone Project: Enterprise System
The ultimate challenge. Apply every skill you've learned to design and build a secure, scalable, and automated multi-tier architecture for a fictional global company.
·DevOps
Module 15 Lesson 2: Capstone: The Infrastructure
Laying the groundwork. Build the complex Docker Compose and networking YAML that will power the GlobalHealth Connect platform.
·DevOps
Module 15 Lesson 3: Capstone: Protected Images
Fortify the binary. Create production-ready, hardened Dockerfiles for the GlobalHealth platform using multi-stage builds and non-root users.
·DevOps
Module 15 Lesson 4: Capstone: CI/CD Strategy
The automation engine. Design the GitHub Actions pipeline that will build, scan, and deploy the GlobalHealth platform to a secure production server.
·DevOps
Module 15 Lesson 5: Final Review & Conclusion
Cross the finish line. A final review of the core competencies of a Docker Architect and next steps for your career in the cloud-native ecosystem.
·DevOps
Module 2 Lesson 1: The Docker Architecture
Look under the hood of Docker. Understand the relationship between the Client, the Host, and the Registry, and how images become containers.
·DevOps
Module 2 Lesson 2: Installing Docker
Get your environment ready. Step-by-step instructions for installing Docker Desktop on Windows and Mac, and Docker Engine on Linux.
·DevOps
Module 2 Lesson 3: Core Docker CLI Commands
Learn the vocabulary of Docker. Master the fundamental commands for pulling images, running containers, and managing your local environment.
·DevOps
Module 2 Lesson 4: Deep Dive into Images and Containers
Master the fundamental lifecycle of Docker. Understand how read-only layers form images and how the 'Writable Layer' makes them come alive as containers.
·DevOps
Module 2 Lesson 5: The Container Lifecycle
From 'Created' to 'Exited'. Learn the different states a container can inhabit and how to transition between them like a pro.
·DevOps
Module 3 Lesson 1: Images vs. Containers (The Builder's View)
Review the fundamental split between static blueprints and live processes, and learn how this distinction shapes the way we build and share software.
·DevOps
Module 3 Lesson 2: Dockerfile Basics
Master the syntax of the Dockerfile. Learn the core instructions (FROM, RUN, COPY, CMD) needed to turn your source code into a portable Docker image.
·DevOps
Module 3 Lesson 3: Docker Layers and Build Caching
Build faster, not harder. Understand how Docker uses caching to skip unnecessary steps and learn how to order your Dockerfile instructions for maximum speed.
·DevOps
Module 3 Lesson 4: Dockerfile Best Practices
Build production-grade images. Learn how to minimize image size, enhance security, and ensure maintainability in your Docker configurations.
·DevOps
Module 3 Lesson 5: Image Tagging and Versioning
Master the art of naming your images. Learn the difference between repository and tag, and why relying on 'latest' is a major anti-pattern in production.
·DevOps
Module 4 Lesson 1: Advanced Container Execution
Go beyond the basic 'run'. Master the advanced flags for port mapping, resource limits, and auto-restart policies to manage production containers effectively.
·DevOps
Module 4 Lesson 2: Managing Container Lifespans
Master the lifecycle management of Docker. Learn the technical difference between stop and kill, and how to safely prune your environment of abandoned containers.
·DevOps
Module 4 Lesson 3: Container Networking Basics
How containers talk to each other. Explore Docker's built-in networking modes and learn how to create private networks for secure inter-container communication.
·DevOps
Module 4 Lesson 4: Volumes and Persistent Storage
Stop losing your data. Learn how to use Docker Volumes and Bind Mounts to ensure your databases and user uploads survive container deletions and upgrades.
·DevOps
Module 4 Lesson 5: Environment Variables and Configuration
Master the 12-factor app principle. Learn how to inject configuration into your containers dynamically, keeping your secrets safe and your images portable across environments.
·DevOps
Module 5 Lesson 1: Introduction to Docker Compose
Stop typing long commands. Discover Docker Compose, the tool that allows you to define and run entire multi-container applications with a single YAML file.
·DevOps
Module 5 Lesson 2: Your First docker-compose.yml
Hands-on with YAML. Learn the structure of a Compose file and build a working stack with a web server and a database in minutes.
·DevOps
Module 3 Lesson 3: Networking and Volumes in Compose
Connecting the dots automatically. Learn how Docker Compose handles networking and persistent storage, making complex configurations simple.
·DevOps
Module 5 Lesson 4: The Docker Compose CLI
Master the commands for managing multi-container stacks. Learn how to view aggregate logs, stop services safely, and rebuild images on the fly.
·DevOps
Module 5 Lesson 5: Real-World Multi-Container Example
The capstone of the basics. Build a complete Voting App architecture with a Python worker, a Redis queue, a Postgres DB, and a Node.js results page.
·DevOps
Module 6 Lesson 1: Multi-Stage Builds
Shrink your images by 90%. Learn the multi-stage build pattern to separate your 'Build Environment' (compilers, tools) from your 'Runtime Environment' (app only).
·DevOps
Module 6 Lesson 1: Service Dependencies and Startup Order
Master the timing of your stack. Learn how 'depends_on' works and how to use 'wait-for-it' scripts to ensure your app only starts after the database is truly ready.
·DevOps
Module 6 Lesson 2: Optimized Layer Order
Master the build cache. Learn how to structure your Dockerfile instructions to minimize 'Cache Invalidation' and keep your build times under 5 seconds.
·DevOps
Module 6 Lesson 2: Scaling Services in Compose
More power. Learn how to use the --scale flag to run multiple instances of a service and how Docker Compose manages the load balancing internally.
·DevOps
Module 6 Lesson 3: Mastering .dockerignore
Protect your secrets and speed up your builds. Learn how to use .dockerignore to keep sensitive and unnecessary files out of your Docker images.
·DevOps
Module 6 Lesson 3: Healthchecks and Restart Policies
Build a self-healing stack. Learn how to configure advanced healthchecks and restart policies directly in your Compose file to automate recovery from crashes.
·DevOps
Module 6 Lesson 4: Docker Healthchecks
Is your app actually alive? Learn how to define HEALTHCHECK instructions in your Dockerfile so your orchestrator can detect and fix 'Zombie' containers.
·DevOps
Module 6 Lesson 4: Extension Fields and YAML Anchors
Dry out your YAML. Learn how to use anchors, aliases, and extension fields to avoid repeating the same configuration across multiple services.
·DevOps
Module 6 Lesson 5: ENTRYPOINT vs. CMD
Demystify the startup instructions. Learn the subtle but important difference between setting a default command and creating an 'Executable' container.
·DevOps
Module 6 Lesson 5: Multi-File Configurations
Master the environment split. Learn how to use multiple Compose files to handle development, staging, and production differences without repeating code.
·DevOps
Module 7 Lesson 1: Docker Security Best Practices
Fortify your containers. Explore the 'Top 10' security practices for hardening Docker images and runtimes against modern threats.
·DevOps
Module 7 Lesson 2: Running as Non-Root
Break the 'Root' habit. Learn why running containers as the administrator is the biggest risk in Docker and how to implement a secure USER instruction.
·DevOps
Module 7 Lesson 3: Image Scanning and Vulnerabilities
Detect the invisible threats. Learn how to use static and dynamic scanning tools to find 'Common Vulnerabilities and Exposures' (CVEs) in your base images and libraries.
·DevOps
Module 7 Lesson 4: Docker Secrets vs. Env Vars
Protect your crown jewels. Learn the technical difference between environment variables and Docker Secrets, and why one is a security risk for production databases.
·DevOps
Module 8 Lesson 1: Consistent Dev Environments
End the 'Onboarding' nightmare. Learn how to use Docker to ensure every developer on your team has the exact same versions of Node, Python, and Databases from Day 1.
·DevOps
Module 8 Lesson 2: Docker Compose for Dev
Master the local dev stack. Learn how to use Docker Compose to manage dependencies like databases and caches alongside your application code.
·DevOps
Module 8 Lesson 3: Hot Reloading with Bind Mounts
Stop rebuilding images. Learn how to use Bind Mounts to link your host source code to your container, enabling 'Instant Feedback' as you type.
·DevOps
Module 8 Lesson 4: Debugging in Containers
See what's happening inside. Learn how to use 'exec', logs, and remote debuggers to troubleshoot applications running inside Docker containers.
·DevOps
Module 8 Lesson 5: Dev vs. Prod Dockerfiles
The right tool for the right job. Learn how to maintain separate Docker configurations for development (speed and debugging) and production (security and size).
·DevOps
Module 9 Lesson 1: Volume Drivers and Types
Master the data layer of Docker. Explore the different volume drivers and types, and learn how to choose the right storage strategy for your application's data.
·DevOps
Module 9 Lesson 1: Introduction to Podman
Meet the daemonless alternative. Explore Podman, the open-source container engine designed for security, rootless execution, and Kubernetes compatibility.
·DevOps
Module 9 Lesson 2: Named vs. Anonymous Volumes
Master the naming conventions of storage. Learn when to use descriptive named volumes and when to let Docker manage anonymous storage for temporary tasks.
·DevOps
Module 9 Lesson 2: Running Rootless Containers
Master the security of the future. Learn how to run containers as a standard user without sudo or root privileges, and understand the trade-offs of rootless execution.
·DevOps
Module 9 Lesson 3: Inspecting and Managing Volumes
Master the administrative side of storage. Learn how to locate your data on the host machine, audit usage, and clean up abandoned storage volumes.
·DevOps
Module 9 Lesson 3: Managing Pods with Podman
Think like Kubernetes. Learn how to use Podman to group related containers into 'Pods', allowing them to share resources and network namespaces like a production cluster.
·DevOps
Module 9 Lesson 4: Volume Plugins and Cloud Storage
Data without borders. Explore how volume plugins allow your containers to store data directly on AWS S3, Azure Files, or Google Cloud Storage for maximum portability.
·DevOps
Module 9 Lesson 5: Backup and Restore Strategies
Protect your data against disasters. Learn the standard patterns for backing up Docker volumes and how to perform a full system recovery from scratch.
·DevOps
Module 1 Lesson 1: What is CI/CD?
Master the fundamental concepts of Continuous Integration and Continuous Delivery. Learn why automation is the heartbeat of modern software engineering.
·DevOps
Module 1 Lesson 2: The Evolution of DevOps
How we got here. Trace the history of software delivery from Waterfall and physical servers to the 'DevOps' movement and the rise of Git-centric automation.
·DevOps
Module 1 Lesson 3: Benefits of Automation
The business case for DevOps. Explore how automated delivery improves code quality, developer happiness, and the bottom line of modern companies.
·DevOps
Module 1 Lesson 4: CI/CD vs CI/CT vs CI/CP
Demystify the acronyms. Learn the subtle differences between Continuous Integration, Testing, Delivery, Deployment, and Policy.
·DevOps
Module 1 Lesson 5: Overview of GitLab Features
The all-in-one platform. Explore the breadth of GitLab's built-in tools, from Runners and Registries to Security Dashboards and Kubernetes integration.
·DevOps
Module 10 Lesson 1: The DRY Principle
Stop the copy-paste. Learn how to use GitLab CI/CD templates to share common jobs across 100 different projects, ensuring consistency and ease of maintenance.
·DevOps
Module 10 Lesson 2: Modular Pipeline Design
Divide and conquer. Learn the architectural patterns of splitting your pipeline into independent, testable modules that are easy for different teams to maintain.
·DevOps
Module 10 Lesson 3: Variable Naming and Scoping
Precision in configuration. Learn the professional standards for naming your CI/CD variables and how to use 'Scoping' to prevent production secrets from leaking into dev builds.
·DevOps
Module 10 Lesson 4: Designing for Resilience
The 'Anti-Fragile' pipeline. Learn how to write CI/CD scripts that can handle network failures, registry timeouts, and flaky tests without completely stopping your company's delivery engine.
·DevOps
Module 10 Lesson 5: Documentation & Handoff
Leave a map. Learn how to document your CI/CD pipelines so that your teammates can maintain them, troubleshoot failures, and onboard new projects without your constant help.
·DevOps
Module 11 Lesson 1: Full-Stack JS Pipeline
From code to cloud. A deep dive into a professional-grade GitLab pipeline for a React/Node.js application, including build, test, and container deployment.
·DevOps
Module 11 Lesson 2: Python/ML Pipeline
Model management at scale. Explore how a data science team uses GitLab CI/CD to build, test, and deploy a Python microservice with GPU support and automated model versioning.
·DevOps
Module 11 Lesson 3: Legacy PHP Conversion
Modernizing the old. A step-by-step case study of taking a manual, high-risk PHP/MySQL application and transforming it into a fully automated containerized pipeline.
·DevOps
Module 11 Lesson 4: Secure Bank Application
Mission critical. Analyze the multi-layered security and compliance pipeline of a national bank, featuring air-gapped runners and mandatory manual approvals.
·DevOps
Module 11 Lesson 5: Global Monorepo
Master the massive. Explore the orchestration of a 100-service monorepo using Parent/Child pipelines, dynamic generation, and advanced caching to keep a large team synchronized.
·DevOps
Capstone Part 1: Architecture and Planning
The big picture. Define the requirements, architecture, and technology stack for your final Enterprise CI/CD project: 'GlobalHealth Connect'.
·DevOps
Capstone Part 2: Building the Pipeline
From theory to YAML. Construct the core logic of the GlobalHealth Connect pipeline, focusing on image building, caching, and cross-stage artifacts.
·DevOps
Capstone Part 3: Security & Quality Gates
Fortify the health system. Implement automated security scans, secret detection, and code coverage requirements for the GlobalHealth Connect platform.
·DevOps
Capstone Part 4: Multi-Tier Deployment
The final stretch. Implement automated delivery to Staging and a manual-trigger, rolling update deployment to the Production environment for GlobalHealth Connect.
·DevOps
Final Review & Conclusion
Mission accomplished. Review the key takeaways from the GitLab CI/CD course and explore the next steps for your career, including the GitLab Certified Associate path.
·DevOps
Module 2 Lesson 1: GitLab Runners
The muscle behind the code. Learn how GitLab Runners execute your jobs, and the critical difference between using GitLab's cloud runners and hosting your own.
·DevOps
Module 2 Lesson 2: The .gitlab-ci.yml Structure
Master the syntax of automation. Learn the basic anatomy of a GitLab CI configuration file, including global settings, job definitions, and hidden keys.
·DevOps
Module 2 Lesson 3: Jobs, Stages, and Scripts
The workflow triplet. Learn how to group jobs into stages to control their execution order and write effective scripts for your automated tasks.
·DevOps
Module 2 Lesson 4: Advanced YAML in GitLab
Master the nuances of YAML. Explore anchors, aliases, and multi-line strings to create cleaner, more maintainable pipeline configurations.
·DevOps
Module 2 Lesson 5: The Pipeline Editor and Linter
Fail fast. Learn how to use GitLab's built-in tools to validate your YAML syntax and visualize your pipeline before you commit your code.
·DevOps
Module 3 Lesson 1: Hello World Pipeline
Your first automated build. Follow a step-by-step guide to creating, committing, and running your very first GitLab CI/CD pipeline.
·DevOps
Module 3 Lesson 2: Environments and Variables
Protect your secrets. Learn how to use GitLab variables to store database passwords and API keys securely, and how to define different 'Environments' for Staging and Production.
·DevOps
Module 3 Lesson 3: Working with Artifacts
Save your work. Learn how to use 'Artifacts' to pass files between stages (e.g., from Build to Test) and how to download them for manual review.
·DevOps
Module 3 Lesson 4: Caching Dependencies
Stop waiting for 'npm install'. Learn the difference between Artifacts and Caching, and how to use Cache to speed up your pipeline by 500%.
·DevOps
Module 3 Lesson 5: Job Control (Rules)
Smart pipelines. Learn how to use 'rules' to decide when a job should run, when it should be manual, and when it should stay hidden.
·DevOps
Module 4 Lesson 1: Multi-Project Pipelines
Connect the dots. Learn how to trigger pipelines in other projects, creating a cross-service automation workflow for complex microservice architectures.
·DevOps
Module 4 Lesson 2: Parent and Child Pipelines
Solve YAML bloat. Learn how to split a massive configuration into smaller, dynamic 'Child' pipelines that only run when needed, keeping your CI fast and readable.
·DevOps
Module 4 Lesson 3: The 'needs' Keyword (DAG)
Break the stage barrier. Learn how to use 'needs' to create a Directed Acyclic Graph (DAG), allowing fast jobs to skip ahead without waiting for slow, unrelated tasks.
·DevOps
Module 4 Lesson 4: Pipeline Triggers and API
Automation beyond Git. Learn how to trigger GitLab pipelines using HTTP requests, custom tokens, and external services like Webhooks or IoT devices.
·DevOps
Module 4 Lesson 5: Optimizing for Large Clusters
Handle the scale. Learn how to optimize GitLab CI/CD for environments with hundreds of runners, thousands of developers, and massive data throughput.
·DevOps
Module 5 Lesson 1: Automated Unit Testing
The first line of defense. Learn how to integrate unit tests into your GitLab pipeline, use test reports, and visualize your code coverage.
·DevOps
Module 5 Lesson 2: Integration Testing & Services
Do they play well together? Learn how to use GitLab 'Services' to spin up temporary databases and caches (like Redis or Postgres) during your integration tests.
·DevOps
Module 5 Lesson 3: Linting and Style Checks
End the bike-shedding. Automate your code style enforcement and static analysis to ensure every developer's code looks like it was written by one person.
·DevOps
Module 5 Lesson 4: Security Scanning (SAST & DAST)
Found the bugs before hackers do. Learn how to integrate Static (SAST) and Dynamic (DAST) security testing into your GitLab pipeline to protect your user data.
·DevOps
Module 5 Lesson 5: Implementing Quality Gates
The point of no return. Learn how to set 'Quality Gates' that prevent poor code from ever reaching the main branch or the customer.
·DevOps
Module 6 Lesson 1: Introduction to Automated Deployment
Cross the finish line. Learn the fundamentals of push-button and fully automated deployments to servers, clouds, and clusters.
·DevOps
Module 6 Lesson 2: Staging vs Production
The safety net. Learn how to manage multi-tier environments in GitLab to ensure that code is tested in a 'Real' world scenario before it hits your paying customers.
·DevOps
Module 6 Lesson 3: Blue-Green vs Canary Releases
Zero downtime mastery. Explore the advanced deployment patterns used by world-class engineering teams to ship code with zero interruptions to the user.
·DevOps
Module 6 Lesson 4: Feature Flags (GitLab Unleash)
Separate deployment from release. Learn how to use Feature Flags to toggle functionality on and off in your live application without redeploying your code.
·DevOps
Module 6 Lesson 5: Rollbacks and Error Recovery
The emergency exits. Learn how to perform instant rollbacks when a deployment goes wrong and how to automate recovery using GitLab's built-in tools.
·DevOps
Module 7 Lesson 1: Docker-in-Docker (DinD)
The chicken and the egg. Learn how to run Docker commands inside a Docker container to build your application images within a GitLab pipeline.
·DevOps
Module 7 Lesson 2: Pushing Images to Registries
The full lifecycle. Learn how to log in to Docker Hub or AWS ECR and push your built images so they can be used by your production servers.
·DevOps
Module 7 Lesson 3: The GitLab Registry
Everything in one place. Learn how to use GitLab's built-in container registry to store your images without needing external accounts or complicated login scripts.
·DevOps
Module 7 Lesson 4: Kubernetes Integration
Master the cloud. Learn how to connect your GitLab project to a Kubernetes cluster and use the 'GitLab Agent' to automate secure deployments to K8s.
·DevOps
Module 7 Lesson 5: Optimizing Builds (Kaniko)
Faster, Safer, Better. Learn how to use Google's Kaniko to build container images without root privileges or a Docker daemon, solving the performance issues of DinD.
·DevOps
Module 8 Lesson 1: Pipeline Notifications
Stay informed. Learn how to configure GitLab's built-in notification system to alert your team via email, webhooks, or the UI whenever a pipeline fails.
·DevOps
Module 8 Lesson 2: Slack and Teams Integration
ChatOps in action. Learn how to connect GitLab to your team's chat platform to get real-time alerts and even trigger deployments directly from a chat channel.
·DevOps
Module 8 Lesson 3: Dashboards and Metrics
Data-driven DevOps. Learn how to use GitLab's built-in analytic dashboards to track your DORA metrics, find bottlenecking jobs, and improve your delivery speed.
·DevOps
Module 8 Lesson 4: Deployment Health
Is it still up? Learn how to use GitLab's Environment Health checks to monitor your live site and trigger alerts if a deployment causes a latency spike.
·DevOps
Module 8 Lesson 5: Security Alerts
Act phase. Learn how to manage the security findings from your scans and setup alerts so that 'Critical' vulnerabilities are dealt with immediately.
·DevOps
Module 9 Lesson 1: Vulnerability Management
The triage process. Learn the professional workflow for identifying, dismissing, or resolving security vulnerabilities within the GitLab ecosystem.
·DevOps
Module 9 Lesson 2: Dependency & License Compliance
Know your supply chain. Learn how to scan your third-party libraries for vulnerabilities and legal risks before they enter your production environment.
·DevOps
Module 9 Lesson 3: Compliance Pipelines
Enforce the rules. Learn how to use GitLab's 'Compliance Frameworks' to force specific security scans on every project in your company, with no exceptions.
·DevOps
Module 9 Lesson 4: Auditing & User Access
Who, what, and when. Master GitLab's Identity and Access Management (IAM) and Audit logs to ensure only the right people can trigger deployments.
·DevOps
Module 9 Lesson 5: Hardening the Runner
Protect the muscle. Learn how to secure your private GitLab Runners to prevent container breakout and ensure your secrets stay on your hardware.