Enroll in Cloud Computing & DevOps

What Is Cloud Computing

Explore the definition of cloud computing and how it differs from traditional on-premises infrastructure. Review real examples of companies that moved to the cloud.

Service Models IaaS PaaS and SaaS

Compare the three main service models and the responsibilities that belong to the provider and the customer. Match common products to each model.

Deployment Models Public Private and Hybrid

Learn when organizations choose public, private, hybrid, or multi-cloud strategies. Discuss tradeoffs in cost, control, and compliance.

Cloud Economics and Pricing

Understand pay-as-you-go pricing, reserved capacity, and total cost of ownership. Estimate the cost of a small workload.

Major Cloud Providers Overview

Tour AWS, Microsoft Azure, and Google Cloud and see how their core services compare. Create a free tier account for upcoming labs.

Virtual Machines and Compute Instances

Launch and connect to a virtual machine while learning about instance types and sizing. Understand how images and regions affect deployments.

Cloud Storage Types

Compare object, block, and file storage and their typical use cases. Create a storage bucket and upload files.

Virtual Networks and Subnets

Learn how virtual private clouds, subnets, and IP ranges are designed. Build a simple network layout.

Security Groups and Firewalls

Control inbound and outbound traffic using security groups and network access rules. Troubleshoot a blocked connection.

Load Balancing and Auto Scaling

Distribute traffic across servers and scale capacity automatically as demand changes. Observe scaling behavior in a demo.

Linux Overview and Distributions

Learn the history of Linux and how distributions such as Ubuntu and CentOS differ. Set up a Linux environment for practice.

Navigating the File System

Move through directories and understand the Linux file system hierarchy. Practice with pwd, ls, and cd.

Working with Files and Directories

Create, copy, move, and delete files and folders from the command line. Use wildcards to work efficiently.

Viewing and Searching Text

Read file contents with cat, less, head, and tail, and search using grep and find. Apply these tools to log files.

Pipes and Redirection

Combine commands with pipes and redirect input and output to files. Build short command chains to process data.

Users and Groups

Create and manage user accounts and groups and understand the role of the root user. Use sudo safely.

File Permissions and Ownership

Read and change permissions with chmod and chown using symbolic and numeric modes. Apply secure defaults.

Package Management

Install, update, and remove software using apt and yum. Learn how repositories work.

Processes and Resource Monitoring

View and control running processes and monitor CPU and memory use with top, ps, and kill. Identify a runaway process.

Services and Systemd

Start, stop, enable, and inspect services using systemctl. Read service logs with journalctl.

Networking Fundamentals for Cloud Engineers

Understand IP addressing, DNS, ports, and common protocols such as HTTP and SSH. Relate them to cloud architectures.

Remote Access with SSH

Connect securely to cloud servers using SSH keys and transfer files with scp. Configure a simple SSH config file.

Network Troubleshooting Tools

Diagnose connectivity issues using ping, curl, netstat, and traceroute. Follow a structured troubleshooting approach.

Introduction to Bash Scripting

Write first scripts using variables, input, and basic commands. Make scripts executable and run them.

Conditionals and Loops in Bash

Add decision making and repetition to scripts with if statements and for and while loops. Automate a repetitive task.

Version Control Concepts and Git Setup

Understand why version control matters and how distributed systems work. Install Git and configure identity and editor settings.

Repositories, Staging and Commits

Initialize repositories and move changes through the working directory, staging area and commit history. Practice writing clear commit messages.

Inspecting History and Differences

Use log, diff and show to explore how a project evolved over time. Filter history by author, date and file.

Ignoring Files and Managing Project Hygiene

Write gitignore rules and keep secrets and build artifacts out of repositories. Learn conventions for clean and maintainable repos.

Undoing Changes Safely

Use restore, reset and revert to correct mistakes at different stages of the workflow. Compare the risks of each approach.

Creating and Switching Branches

Create feature branches and move between them without losing work. Understand how branch pointers work internally.

Merging and Resolving Conflicts

Perform fast-forward and three-way merges and resolve conflicting changes by hand. Use merge tools to confirm correct results.

Rebasing and Clean History

Rebase branches and squash commits to keep history linear and readable. Learn when rebasing is unsafe.

Working with Remotes

Clone, fetch, pull and push against remote repositories. Track upstream branches and keep local copies in sync.

Pull Requests and Code Review

Open pull requests and give and receive constructive review feedback. Use protected branches and required checks.

Shell Script Basics

Write the first script with a shebang line and set execute permissions. Run scripts and understand exit codes.

Variables, Input and Arguments

Use variables, command substitution, user prompts and positional parameters. Quote values correctly to avoid common bugs.

Conditionals and Test Expressions

Control script flow with if statements, case blocks and file and string tests. Combine conditions with logical operators.

Loops and Iteration

Process lists, files and command output with for and while loops. Handle line-by-line input reliably.

Functions and Reusable Scripts

Organize logic into functions and source shared libraries. Return values and manage variable scope.

Pipes and Redirection in Practice

Chain commands with pipes and redirect standard streams to files. Build useful one-line data pipelines.

Searching with grep and Regular Expressions

Match patterns in logs and configuration files using grep and regex syntax. Extract exactly the lines that matter.

Transforming Text with sed and awk

Edit streams with sed substitutions and summarize columnar data with awk. Apply both tools to real log files.

Working with JSON and YAML on the Command Line

Parse and modify structured data using jq and yq. Prepare for reading cloud API output and configuration files.

Scheduling with Cron and Systemd Timers

Schedule recurring jobs using crontab syntax and systemd timers. Capture output and handle failures.

Python Environment and Virtual Environments

Set up Python and isolate project dependencies with venv and pip. Manage requirements files for repeatable setups.

Python Syntax for Automation

Review data types, control flow and functions with a focus on operational scripts. Write small utilities for daily tasks.

File System and Process Automation

Use os, pathlib and subprocess to manage files and run system commands. Capture output and handle errors.

Calling REST APIs with Requests

Send authenticated HTTP requests and parse JSON responses. Handle status codes, retries and timeouts.

Automating Cloud Resources with Python SDKs

Use a cloud provider SDK to list, create and tag resources programmatically. Apply least-privilege credentials.

AWS Global Infrastructure and Console Tour

Explore regions, availability zones, and edge locations while navigating the AWS Management Console. Learners practice choosing regions based on latency, cost, and compliance.

Creating and Securing an AWS Account

Set up a new account with root user protection and multi-factor authentication. Learners configure billing alerts and budgets to avoid surprise charges.

IAM Users, Groups, and Roles

Learn how IAM identities are created and organized for least-privilege access. Learners build users, groups, and roles for common team scenarios.

IAM Policies and Permission Boundaries

Read and write JSON policies that allow or deny actions on resources. Learners test policies using the IAM policy simulator.

AWS CLI and SDK Access

Configure the AWS CLI with named profiles and access keys or temporary credentials. Learners run basic commands and a short SDK script to manage resources.

Launching EC2 Instances

Choose instance types, AMIs, and key pairs to launch a virtual server. Learners connect over SSH and verify the running instance.

Instance Storage and EBS Volumes

Attach, format, and snapshot EBS volumes for persistent storage. Learners compare EBS with instance store and restore from a snapshot.

EC2 Pricing Models and Cost Optimization

Compare on-demand, reserved, spot, and savings plan options. Learners estimate costs for sample workloads using the pricing calculator.

Load Balancing and Auto Scaling

Distribute traffic with an Application Load Balancer and scale instances automatically. Learners configure scaling policies based on CPU metrics.

AWS Lambda and Event-Driven Functions

Build serverless functions triggered by events such as file uploads or schedules. Learners deploy a Lambda function and review its logs.

Amazon S3 Buckets and Objects

Create buckets, upload objects, and organize data with prefixes. Learners explore storage classes and durability guarantees.

S3 Security, Versioning, and Lifecycle Rules

Protect data with bucket policies, encryption, and versioning. Learners set lifecycle rules to move or expire older objects.

Static Website Hosting with S3 and CloudFront

Host a static site from S3 and speed up delivery through a CDN. Learners configure caching and HTTPS for the site.

Relational Databases with Amazon RDS

Launch a managed database and configure backups and multi-AZ deployment. Learners connect to the database from an EC2 instance.

NoSQL with DynamoDB

Model data with tables, partition keys, and indexes. Learners perform basic read and write operations and understand capacity modes.

VPC Design and CIDR Planning

Plan IP address ranges and create a custom VPC. Learners practice subnetting and avoiding overlapping CIDR blocks.

Public and Private Subnets with Route Tables

Build subnets across availability zones and control traffic paths using route tables. Learners decide which resources belong in each subnet type.

Internet Gateways and NAT Gateways

Give public resources internet access and let private resources reach out safely. Learners test connectivity from both subnet types.

Security Groups and Network ACLs

Compare stateful and stateless traffic filtering at the instance and subnet levels. Learners write rules and troubleshoot blocked connections.

VPC Peering and Transit Connectivity

Connect separate VPCs using peering and learn when a transit gateway fits better. Learners configure routes between two VPCs.

DNS with Route 53

Register domains and create hosted zones with common record types. Learners point a domain name to a load balancer or website.

Routing Policies and Health Checks

Use weighted, latency-based, and failover routing to direct users. Learners configure health checks to trigger automatic failover.

Monitoring with CloudWatch Metrics and Logs

Collect metrics and logs from AWS resources and view them on dashboards. Learners create custom metrics and log filters.

Alarms and Notifications with SNS

Set alarms on key metrics and send alerts through email or messaging topics. Learners build a simple alerting workflow for an EC2 instance.

Well-Architected Framework Principles

Review the pillars of reliability, security, performance, cost, and operational excellence. Learners assess a sample architecture against these pillars.

Containers versus Virtual Machines

Compare container and VM architectures and learn when each is the right choice. Explore namespaces and cgroups at a conceptual level.

Installing Docker and Running Containers

Set up Docker on a workstation and run containers from public images. Practice starting, stopping and removing containers.

Working with Images and Registries

Pull, tag and push images using Docker Hub and Amazon ECR. Learn how image layers and tags work.

Inspecting and Debugging Containers

Use logs, exec, inspect and stats to diagnose a misbehaving container. Learn common exit codes and their meanings.

Container Networking Basics

Understand bridge, host and none networks and how published ports work. Connect containers to each other by name.

Writing Your First Dockerfile

Learn core instructions such as FROM, COPY, RUN, CMD and ENTRYPOINT. Containerize a simple web application.

Layer Caching and Build Optimization

Order instructions to take advantage of the build cache and use dockerignore files. Measure build time and image size improvements.

Multi-Stage Builds

Separate build and runtime stages to produce small final images. Apply the pattern to a compiled and an interpreted application.

Image Security and Scanning

Use minimal base images, non-root users and vulnerability scanners. Fix findings reported by a scan tool.

Docker Compose for Multi-Container Apps

Define a web app, database and cache in one Compose file. Manage environment variables, networks and dependencies.

Kubernetes Architecture Overview

Study the control plane, worker nodes, kubelet and etcd. Understand how a request flows through the cluster.

Setting Up a Local Cluster and kubectl

Create a local cluster with kind or minikube and configure kubectl contexts. Run basic commands to explore cluster state.

Pods and Their Lifecycle

Write Pod manifests in YAML and observe how Pods start, restart and terminate. Add probes to check health.

Deployments and ReplicaSets

Run replicated applications and perform rolling updates and rollbacks. Understand how ReplicaSets maintain desired state.

Services and Cluster Networking

Expose applications with ClusterIP, NodePort and LoadBalancer Services. Learn how service discovery and kube-proxy work.

ConfigMaps and Secrets

Decouple configuration from images using ConfigMaps and Secrets. Inject values as environment variables and mounted files.

Persistent Volumes and Claims

Provision durable storage with PersistentVolumes, claims and storage classes. Attach storage to a database Pod.

StatefulSets and Stateful Workloads

Run ordered, stable-identity workloads such as databases with StatefulSets. Compare them with Deployments.

Ingress and Traffic Routing

Route external HTTP traffic to multiple services using an Ingress controller. Configure host and path rules.

Resource Requests, Limits and Autoscaling

Set CPU and memory requests and limits and configure the Horizontal Pod Autoscaler. Observe scaling under simulated load.

Managed Kubernetes with Amazon EKS

Provision an EKS cluster and connect to it with kubectl. Understand node groups and the shared responsibility model.

Deploying an Application to EKS

Push an image to ECR and deploy it to EKS behind a cloud load balancer. Validate the release end to end.

RBAC and Kubernetes Security

Control access with roles, role bindings and service accounts. Apply network policies and Pod security settings.

Monitoring and Logging with Prometheus and Grafana

Collect cluster and application metrics and build dashboards. Set up a basic alert rule.

Troubleshooting Kubernetes Workloads

Diagnose CrashLoopBackOff, ImagePullBackOff and pending Pods using describe, logs and events. Follow a repeatable debugging workflow.

Continuous Integration Fundamentals

Understand why teams integrate code frequently and how automated builds catch defects early. Map the stages of a typical CI workflow from commit to build artifact.

Continuous Delivery versus Continuous Deployment

Compare delivery and deployment models along with their approval gates and risk profiles. Decide which approach fits different team and product contexts.

Designing Pipeline Stages

Structure pipelines into build, test, scan, package and deploy stages. Learn how to keep stages fast, isolated and repeatable.

Automated Testing in Pipelines

Integrate unit, integration and smoke tests into automated workflows. Learn how to fail fast and report results clearly.

Artifact Management and Versioning

Store build outputs in registries and repositories with consistent version tags. Practice semantic versioning and artifact promotion across environments.

GitHub Actions Workflows and Triggers

Write workflow files that respond to pushes, pull requests and schedules. Understand jobs, steps and runners.

Reusable Actions and Matrix Builds

Create reusable workflows and run builds across multiple versions and platforms. Reduce duplication while widening test coverage.

Secrets and Environment Management

Store credentials securely and scope them to specific environments. Apply protection rules and manual approvals for production.

Jenkins Architecture and Setup

Install Jenkins and configure controllers, agents and plugins. Understand how Jenkins schedules and executes builds.

Declarative Jenkins Pipelines

Author Jenkinsfiles using declarative syntax with stages, conditions and post actions. Store pipeline definitions alongside application code.

Infrastructure as Code Concepts

Learn the benefits of declarative infrastructure including consistency, auditability and speed. Compare imperative and declarative approaches.

Terraform Workflow and HCL Basics

Use init, plan and apply to manage resources written in HashiCorp Configuration Language. Read plan output to predict changes.

Providers, Resources and Data Sources

Configure the AWS provider and define resources such as instances and buckets. Query existing infrastructure with data sources.

Variables, Outputs and Locals

Parameterize configurations to make them reusable across environments. Expose useful values through outputs.

Remote State and Locking

Store state in remote backends with locking to enable safe team collaboration. Understand state files and how to protect them.

Configuration Management Overview

Understand the role of configuration management alongside provisioning tools. Compare Ansible, Chef and Puppet at a high level.

Ansible Inventory and Ad Hoc Commands

Define inventories of hosts and run quick commands across them over SSH. Learn how Ansible operates without agents.

Writing Ansible Playbooks

Create playbooks with tasks, handlers and variables to configure servers. Practice writing idempotent and readable automation.

Ansible Roles and Vault

Organize automation into roles and protect sensitive data with Ansible Vault. Share and reuse roles across projects.

GitOps Principles

Treat Git as the single source of truth for infrastructure and application state. Explore pull based reconciliation and drift detection.

Shifting Security Left with DevSecOps

Embed security checks early in the development lifecycle. Understand shared responsibility between developers and operations.

Static Analysis and Dependency Scanning

Add code quality and vulnerability scans to pipelines using SAST and software composition analysis tools. Triage findings and set pass or fail thresholds.

Container Image and IaC Scanning

Scan container images and Terraform code for misconfigurations and known vulnerabilities. Block risky changes before they reach production.

Blue Green and Canary Deployments

Release changes gradually or in parallel environments to reduce risk. Compare traffic shifting techniques and rollback speed.

Feature Flags and Rollback Strategies

Decouple deployment from release using feature flags. Plan reliable rollback procedures for failed releases.

Principles of Observability

Understand the difference between monitoring and observability and the role of metrics, logs and traces. Learn how golden signals guide what to measure.

Amazon CloudWatch Metrics and Alarms

Create custom metrics, dashboards and alarms for EC2 and managed services. Configure notifications through SNS.

Centralized Logging with CloudWatch Logs and ELK

Ship application and system logs to a central store and query them effectively. Compare managed logging with the ELK stack.

Prometheus and Grafana for Kubernetes

Deploy Prometheus and Grafana on a cluster to scrape metrics and build dashboards. Write basic PromQL queries.

Distributed Tracing and Application Performance

Trace requests across microservices using OpenTelemetry and AWS X-Ray. Identify latency bottlenecks in service calls.

Shared Responsibility and Security Fundamentals

Learn the shared responsibility model and core security principles such as least privilege and defense in depth.

IAM Policies Roles and Federation

Write IAM policies and configure roles for services and cross-account access. Review MFA and single sign-on options.

Data Protection with KMS and Encryption

Encrypt data at rest and in transit using KMS and TLS certificates. Manage key rotation and access to keys.

Secrets Management and Secure Configuration

Store and rotate credentials with AWS Secrets Manager and Parameter Store. Keep secrets out of code and pipelines.

Network Security and Perimeter Defense

Harden VPCs using security groups, NACLs, WAF and Shield. Apply private connectivity patterns to reduce exposure.

Shifting Security Left in CI/CD

Integrate security gates into pipelines from commit to deploy. Understand where each type of scan fits.

Static and Dependency Scanning

Run SAST and software composition analysis to catch code flaws and vulnerable libraries. Triage and fix findings.

Container Image and Kubernetes Security

Scan images with Trivy and apply pod security standards, network policies and RBAC. Reduce the container attack surface.

Infrastructure as Code Policy Checks

Validate Terraform with tools like Checkov and enforce rules using policy as code. Block risky changes before they reach production.

Compliance and Governance with AWS Config

Use AWS Config and Security Hub to track configuration drift and compliance posture. Map controls to common frameworks.

Cloud Financial Management Basics

Understand cost drivers and use Cost Explorer, budgets and tagging to gain spend visibility.

Right-Sizing and Pricing Models

Choose between on-demand, reserved, savings plans and spot capacity. Right-size compute based on utilization data.

Autoscaling and Performance Tuning

Configure autoscaling policies and load test applications to tune capacity. Balance performance against cost.

Reliability Engineering and Chaos Testing

Apply reliability patterns such as retries, circuit breakers and health checks. Run simple chaos experiments to validate resilience.

Well-Architected Framework Review

Evaluate a workload against the six pillars of the AWS Well-Architected Framework. Produce an improvement plan from the findings.

Capstone Planning and Architecture Design

Define requirements and design the capstone architecture covering networking, compute, pipeline and monitoring. Document decisions in a diagram and design brief.

Building Infrastructure and Pipeline for the Capstone

Provision the capstone environment with Terraform and set up a CI/CD pipeline. Apply version control workflows in a team setting.

Deploying the Application to Kubernetes

Containerize the application and deploy it to a cluster with rolling updates and configuration management. Expose it securely through an ingress.

Adding Monitoring and Security Controls

Instrument the capstone with dashboards, alerts and security scans. Verify IAM, secrets and network controls against a checklist.

Capstone Demo and Peer Review

Present the deployed solution live and explain design trade-offs. Give and receive structured feedback from peers and mentors.