Git and Docker

23 courses, 346 lessons. A real Kali Linux lab in the browser.

Git fundamentals (Level 101, 18 lessons): Repositories, commits, branches, merging and remotes.
Docker fundamentals (Level 101, 18 lessons): Images, containers, networks and volumes.
VS Code fundamentals (Level 101, 14 lessons): You learn to use the editor, the integrated terminal, search and multiple cursors, the Git panel and extensions comfortably in daily work.
Teamwork with Git: branches and workflows (Level 201, 17 lessons): You practise working in one repository as a team: branch strategies, code review and keeping remotes tidy.
Shaping Git history: rebase, cherry-pick, bisect (Level 201, 16 lessons): You learn to rewrite history safely, move changes between branches and find the commit that introduced a bug.
Git practice: real situations from a team (Level 201, 15 lessons): You solve short Git problems from a team’s day without guidance; each task is a little harder than the last.
Multi-service apps with Docker Compose (Level 201, 15 lessons): You describe apps made of a web tier, a database and a cache in one file, and move and update them across environments.
Docker networking and storage (Level 201, 16 lessons): You learn bridge, host and overlay networks, container DNS, volume drivers and data backups by looking at packets and files.
Docker practice: real situations (Level 201, 16 lessons): You solve common problems in containerised apps without guidance, finding the cause and making a lasting fix each time.
PowerShell scripts, functions and modules (Level 201, 16 lessons): You write reusable PowerShell tools with advanced functions that take parameters, proper error handling and modules.
Debugging and remote development with VS Code (Level 201, 15 lessons): You debug Python and Bash with breakpoints, and develop on servers and in containers with Remote-SSH and Dev Containers.
Git internals and hooks (Level 301, 16 lessons): You open up the object database, refs and pack files, and write your own checks with hooks.
Large repositories: submodules, worktrees, LFS and signing (Level 301, 15 lessons): You learn to cope with growing repositories, use several working trees and prove where commits come from by signing them.
Advanced image building: multi-stage, BuildKit and registries (Level 301, 17 lessons): You make small, fast-building, reproducible images, run your own registry and version and sign your images.
Troubleshooting and monitoring Docker (Level 301, 16 lessons): You learn to find why containers crash, slow down or eat resources, using logs, metrics and events.
Remote management and automation with PowerShell (Level 301, 15 lessons): You manage domain Windows servers in bulk with PowerShell Remoting, schedule jobs and narrow rights with JEA.
Host your own Git server: SSH and Gitea (Level 401, 15 lessons): You build an in-house Git server, from bare repositories over SSH to Gitea with a web interface, and secure, back up and restore it.
Running Docker in production: Swarm (Level 401, 14 lessons): You build a Swarm cluster across several servers, update services without downtime, manage secrets and back up and restore the cluster.
Testing and configuration management in PowerShell: Pester and DSC (Level 401, 12 lessons): You test your scripts with Pester, describe server configuration as code with DSC and catch drift.
Job role: build and release engineer (Level 401, 13 lessons): As a software team’s release engineer you run release branches with Git, image builds with Docker and a local delivery pipeline end to end.
Recovery and forensics in Git (Level 501, 12 lessons): You recover corrupted, wrongly rewritten or tampered repositories and answer who changed what and when, with evidence.
Inside Docker: namespaces, cgroups, OCI and runc (Level 501, 12 lessons): You build a container by hand from kernel features without Docker and see what containerd, runc and the OCI specs do at each layer.
Toolmaking with PowerShell (Level 501, 13 lessons): You build versioned, documented tools your team will use every day, using classes, .NET, parallel jobs and binary modules.

Projects

Commit a configuration change properly: You record a configuration file change in Git with a clear message so a teammate can read what changed and why.
Undo a bad change safely: You undo a change that was saved by mistake without damaging history, and show the files are back to their last healthy state.
Package a web app in a container: You package a web application into a container image and deliver it, showing it runs the same way on another machine.
A bulk configuration change with PowerShell: You change the same setting across many configuration files with PowerShell and produce a summary showing every file was updated correctly.
Build an operations toolkit (Bash and Git): You build a toolkit of Bash scripts that makes a team's daily work easier, keep it under Git version control, and hand it over with a usage guide.
Merge a team’s changes and resolve conflicts: You merge changes two people made to the same file, resolve the conflicts by hand, and confirm the result keeps both people's work.
Run a batch job in a container: You run a one-off data job inside a container and show that it exits cleanly and its output is saved on the host machine.
Apply a security patch to an older release: You apply the fix for a newly found vulnerability to an older release that is still in use, and confirm with a test that the weakness is closed.
Find the change that broke it with git bisect: You use git bisect to halve the history and find which change introduced a bug, then report that change together with the evidence.
A multi-service app with Docker Compose: You bring up a system made of a web front end, an application and a database with Docker Compose and show the services can find each other.
Deliver an image to an offline environment: You carry a container image as a file into an environment without internet, load and run it there, and verify the image was not altered.
Give an application its own staging environment: You create a staging environment separate from production for an application and show that testing never touches live data.
Keep data across container rebuilds: You make sure a database container's records survive deleting and recreating it, and prove it with a before-and-after check.
Put memory and CPU limits on containers: You set memory and CPU limits on containers and show that one application using too much does not hurt the others.
Stop a container’s work safely: You make an application shut down cleanly when its container is stopped so unfinished work is not lost, and show the data stays intact.
Build a small and secure image: You build a small container image stripped of unneeded tools and running as an unprivileged user, and report the smaller size and fewer known weaknesses.
Enforce repository rules with Git hooks: You write Git hooks for the software team of Yelkovan Bankası: client hooks that check the message format and keep passwords or keys out of the repository, and a server hook that rejects direct pushes to the main branch. You show each rule stops a deliberate violation.
Diagnose and repair a broken container stack: The parcel tracking application of Kuzeyyıldızı Kargo will not come up under Compose: one service keeps restarting, one hits its memory limit, one cannot find the database by name. You find the three causes with logs, events and inspection commands, fix them and write a fault note.
Set up an in-house Git server (Gitea): You set up a Git server with Gitea for the IT unit of Selvikent Belediyesi: SSH access, teams and permissions, main branch protection and required signed commits. You back the server up, restore it into an empty environment and show the repositories arrive complete.
Recover lost Git history and document what happened: A week of work has vanished from the main repository of Göktaşı Yazılım after a forced push, and some objects are damaged. On a prepared copy of the repository you bring the lost commits back with the reflog, fsck and dangling objects, and write a timeline showing who changed what and when.