Online DevOps, Cloud Computing & Cybersecurity Course

How lists, dictionaries, and sets work and how to use them to organise infrastructure data like instance inventories, config entries, and log records.

Using 2-D lists to model grid-based infrastructure topologies - the same data structure behind placement schedulers that decide which pod lands on which node.

Building Dictionary and Set operations that power deduplication engines in log aggregation pipelines - turning a 10,000-line CloudWatch export into a unique, actionable list in milliseconds.

Navigating the underlying filesystem and container; mastering permissions and directory structures

Understanding Linux file permission models (read/write/execute across owner/group/world) to correctly configure service accounts on hosts - the same model enforced inside Docker containers and Kubernetes pods.

Managing filesystem mounts, symbolic links, and directory structures - the operations behind attaching persistent volumes to containers and configuring shared storage paths that survive container restarts.

Write production-ready Shell scripts that combine file operations, process control, and network checks into reliable, portable automation.

Building end-to-end Shell scripts that chain file management, process control, and network verification into a single portable automation - running identically on any Linux cloud instance.

Writing DevOps file management scripts that atomically move, archive, and clean up build artifacts and log files as a standard pipeline step - keeping disk usage predictable and bounded.

What containers are, why they replaced VMs for most workloads, and how to install Docker and run your first container.

Installing Docker and running your first container - pulling images, starting and stopping containers, and inspecting logs to understand the container lifecycle from the command line.

Writing a Dockerfile to package a simple application into a container image - understanding the build context, layer caching, and how each instruction affects the final image.

What Jenkins is, how to install and configure it, and how to create your first jobs that pull code, run builds, and report results.

Installing Jenkins on a local machine or cloud instance, completing the initial setup wizard, and navigating the dashboard - the first steps before building any pipeline.

Creating simple Jenkins jobs - configuring freestyle projects that pull code from a Git repository, run a build script, and report pass/fail status back to the team.

Choose the right EC2 instance types for your workload and configure Application Load Balancers to distribute traffic for zero-downtime deployments.

Selecting EC2 instance types, storage options, and placement groups to match workload requirements - understanding the cost and performance tradeoffs before provisioning for production.

Configuring Application Load Balancers with target groups, health checks, and path-based routing rules - building the traffic layer that enables zero-downtime rolling deployments.

Write reusable Terraform modules, manage remote state safely across teams, and use Workspaces to deploy the same infrastructure across multiple environments.

Writing Terraform modules to define reusable infrastructure components - VPCs, EKS clusters, RDS instances - instantiated across dev, staging, and production from a single source of truth.

Managing Terraform state with remote backends (S3 + DynamoDB state locking) to enable safe, concurrent infrastructure changes across a team.

Using Terraform Workspaces and dependency management to orchestrate complex multi-resource deployments in the correct order.

How Consistent Hashing distributes load across nodes and how CAP Theorem guides the tradeoffs between availability and consistency in distributed systems.

Understanding how Consistent Hashing enables load distribution across a dynamic set of cache nodes - scaling distributed caches horizontally without rehashing all keys when a node joins or leaves.

Applying CAP Theorem to real architectural decisions - choosing eventual consistency for high-availability systems where brief staleness is acceptable, and strong consistency for financial systems where it is not.

Build versioned data pipelines and feature stores that keep training data reproducible and prevent training-serving skew from silently degrading model performance.

Implementing feature stores to share and reuse engineered features across models - eliminating the training-serving skew that is the silent bug behind the majority of model performance regressions.

Managing data lineage and schema evolution so upstream changes to raw data don't silently corrupt model inputs - the quality foundation that separates an ML system that degrades gracefully from one that produces confidently wrong outputs.

How graphs and tree structures model real infrastructure problems like service dependency maps, resource hierarchies, and prefix-based routing rules.

Applying BFS and DFS to traverse service dependency graphs - detecting circular dependencies in Terraform modules, mapping upstream/downstream blast radius of a failing component, and planning the correct order of resource teardown.

Using Trees and BST operations for efficient range queries - the data structure behind log indexing systems that retrieve all events within a specific time window in O(log n) rather than scanning the full dataset.

Implementing Trie structures for prefix-based lookups - the data structure behind namespace-filtered resource queries in Kubernetes and log routing rules that match on service name prefixes.