Ultimate DevSecOps With Real World Scenarios

Trace the history of Unix from Bell Labs origins to Linux's kernel rise, including Minix, and note Linus Torvalds created Linux in 1991 as a GNU-powered, Unix-like kernel—not a clone.

Compare Linux and Unix as open source vs licensed multitasking, multi-user systems, noting Linux's 1991 origins and Unix's 1969 Bell Labs roots.

Explore the Unix and Linux architecture, from the application and shell layers to the kernel and hardware, and learn how commands, utilities, and file systems interact under root permissions.

Navigate the Linux directory structure from the root to key folders like /bin, /usr, /etc, /var, /home, /boot, and /proc. Learn about binaries, configuration files, and device files.

Explore basic Linux commands, and learn how environment variables, including the PATH variable, influence where Linux searches for executables.

Learn Linux commands to list files with ls, navigate with cd, inspect content with cat, echo the bath environment variable, view the home directory, and use which and man pages.

Learn Linux directories, absolute vs relative paths, dot and dot dot, root, and tilde home navigation; use cd, pwd, mkdir -p, rmdir, and rm -r -f to manage them.

Explore absolute and relative paths, dot and dot dot, and directory operations with cd, mkdir -p, and rm -rf in a hands-on session.

List and understand the ls output by using the -l a t options to show a long, all-files, human-readable list sorted by last modified time, including hidden files.

List files with the ls command, reveal hidden files with -a, view detailed permissions with -l, and sort by modification time with -t, using -h for human readable sizes.

Explore Linux links and shortcuts, including hard links and symbolic links, using the ln command; understand inodes as the data structure that stores a file's attributes and disk blocks.

Learn to create and manage hard and soft (symbolic) links with ln, including directory constraints, absolute paths, and cd -P to reach the original, with links acting as shortcuts.

Learn to read and assign Linux file and directory permissions, including owner, group, and others, using numeric and symbolic chmod, plus setuid, setgid, and sticky bits.

Master Linux file and directory permissions, with owner, group, others; apply read, write, execute, use numeric or symbolic chmod, and sticky bits like user ID and group ID.

Learn to use find and locate to search files in current or absolute paths, apply -name, -iname, and -exec, and update the locate database with updatedb.

Learn to view and edit files with the nano editor, and display contents using cat, more, less, head, and tail commands, including tail -f.

Master file viewing with cat, more, less, head, tail, and tail -F, including real-time log monitoring, and explore editing with nano and vim.

Explore the differences between vi, vim, and view, and master core vi/vim shortcuts for editing, navigation, saving, quitting, and searching, including the read-only mode of view.

Master vim and vi for editing system files, switching from read-only view to insert mode. Learn visual editing, yank, paste, and undo to edit efficiently.

Master Linux copy, move, and rename commands with cp and mv, practice deleting with rm and wildcards, and safely manage files using touch and ls.

Explore Linux input output and redirection by learning file descriptors, including stdin (0), stdout (1), and stderr (2), and how to redirect with >, >>, <, and to /dev/null.

Master redirection by saving command output to files with greater than, feeding input from files with less than, appending results, and redirecting errors to dev null.

Compare files using diff, side-by-side, and vimdiff to identify changes between file1.txt and file2.txt. The hands-on session highlights interpreting added, modified, and missing lines with visual cues for clarity.

Transfer files over the network with scp, using ssh rsa keys and the -i option to copy between local and remote servers, preserving or renaming paths.

Create and use shell aliases to shorten commands, such as mapping 'c' to 'clear', and persist them across login and non-login shells via dot bashrc and dot profile.

Learn how environment variables serve the system, not just a symbol, and how to set them in per-user and system-wide profiles using env, profile files, and source commands.

Master Linux process management and job control using ps, top, and kill; run tasks in background with ampersand, manage foreground and background with bg and fg, and track jobs.

Master Linux processes and job control by managing foreground and background tasks, viewing PIDs, and using top or htop to monitor, while using bg, fg, and kill with signals.

Master scheduling repeated jobs with cron using crontab to install, list, edit, and remove cron jobs. Grasp cron pattern for minutes, hours, day of month, month, and day of week.

Learn how to schedule tasks with cron using crontab, listing, editing, and removing jobs. Explore the hands-on approach with vim, sudo, and user-specific crontab entries, including the every-minute example.

Learn to inspect Linux history with the history command, locate dot history and .bash_history files, adjust history length, and consider clearing or disabling history to protect credentials.

Learn how sudo enables commands as root or other users, inspect the sudoers and sudoers.d files, and assess risks of passwordless sudo and safe editing on Ubuntu in AWS.

Master Linux user and group management using add user and useradd, assign sudo privileges, review groups and uid/gid, and safely remove users along with their home directories.

Explore the linux boot process from bios and mbr to grub, kernel, init, and runlevel programs, including systemd and rc scripts that start services.

Learn to use df for disk usage, du -h for disk utilization, and mount for attaching file systems, while understanding dot and dot dot directories, and absolute versus relative paths.

Explore the basics of shell scripting for beginners, covering the Unix shell, comments, variables and special variables, operators, if else, case esac, and loops with functions.

Explore linux operators by using shell variables, back quotation, and echo to store and display values. Apply expr for arithmetic with proper spacing and perform minus, multiplication, division, and modulus.

Discover shell scripting loops in Linux, focusing on while and for constructs, their syntax, and how break and continue control flow with practical examples.

Explore shell scripting basics by defining variables and special variables, setting executable permissions, using shebang, executing scripts, passing arguments, and tracking exit status, pid, and background processes.

Explore how to define and invoke a simple hello function, using echo to print hello world and understanding function semantics as a foundation of programming.

Master bash decision making with if-else, elif, and case statements, and practice numeric and string comparisons using -eq, -ne, -lt, -le, -gt, with practical shell examples.

This interview prep defines linux as a unix-based kernel open source operating system, contrasts unix and linux, explains the linux kernel, and discusses boot loaders lilo and grub.

Master Linux interview basics: rename files with mv and understand inode and metadata. Cover at scheduling, pid, distros like Red Hat, Debian, Fedora, swap, Bash, root, CLI vs GUI.

Master Linux fundamentals for interviews, including file permissions, vi editing basics, redirection, gzip and gunzip usage, grep searches, and understanding virtual desktop.

Learn to install Python on Kali Linux and other platforms, choose Python 3 over Python 2, understand interpreter versus compiler, and set up Visual Studio Code for Python development.

Write your first hello world program in Python, save it as first.py, and run it with Python 3 to see the output in the terminal.

Explore data types in Python, covering fundamental types like int, float, bool, string, list, tuple, set, dict, plus classes and the concept of None.

Explore Python numbers in DevSecOps context by printing values and performing arithmetic to see int results become floats. Use type() to check data types and practice exponentiation with **.

Explore Python's standard library math functions, including round and abs, with quick demonstrations and official docs, within a devsecops course focused on ethical hacking and cybersecurity.

Explore operator precedence in Python, where brackets have the highest precedence, then exponential, then multiplication and division, and finally addition and subtraction, illustrated with simple print examples.

This lecture introduces Python variables, demonstrates integer and float assignments, printing results, and combining variables to compute sums, including multiple assignments on a single line.

Explore how Python handles strings with dynamic typing, including single and double quotes, multiline strings, and string concatenation. Avoid hard coding passwords; use environment variables or secret managers in production.

Master escape sequences by using a backslash to escape characters like the single quote, create new lines with backslash n, and print a literal backslash with double backslashes.

Learn to perform type conversions by using str and int functions to convert between string and integer, test with the type function, and handle concatenation and common parsing errors.

Learn to print dynamic messages with formatted strings by embedding variables like user and age, then adjust output by indexing and reordering arguments.

Explore how strings are sequences of characters and master zero-based indexes to access individual characters and slice substrings using end-exclusive ranges from a start index to another index.

Explore boolean data types by testing true and false, using var and print, and converting values with a bool function so zero becomes false and one becomes true.

Discover how lists store sequences of diverse objects, index from zero, print elements and slices, and handle out-of-range errors in practical devsecops scenarios.

Explore built-in Python list methods such as append, clear, sort, and more, learn what to memorize versus how to search for method usage, with a practical sorting example.

Learn how matrices function as multi-dimensional arrays in Python, using two-bracket indexing to access elements, print values, and distinguish string literals from variables.

Explore how none represents a value not set yet, distinct from zero or white space, and observe through print statements that none is a separate type with an arbitrary value.

Master dictionaries by using key value pairs, access values with keys, and print specific fields like name and age. Explore nesting dictionaries in lists and printing targeted data.

Discover Python dictionary methods such as clear, copy, fromkeys, get, items, keys, pop, popitem, setdefault, update, and values, with examples to learn their use.

Discover how tuples create a read-only table in Python, where data cannot be modified or sorted, unlike lists that allow item assignment.

Master Python conditional logic with if, else, and nested if else, using booleans and relational operators, and follow indentation rules for clear multi-branch decision making.

Learn how a Python for loop iterates over items, prints values inside the loop, and how the loop variable ends with its final value after completion due to indentation.

Demonstrates using the range function to power a for loop counter, printing 0 to 9 by default and showing that end is exclusive; set end to 11 to include 10.

Show how a basic while loop starts at zero, prints i while i is less than five, and increments until it reaches five to avoid an infinite loop.

Learn how break, continue, and pass control flow affect Python loops, fix infinite loops, and illustrate practical examples inside while and for loops.

Learn to define and call user-defined Python functions with def, parameters, and return values. Explore built-in functions and local versus global scope through practical examples.

Learn to handle variable numbers of parameters with *args and **kwargs, pass many integers, print and access positional arguments as a list and keyword arguments as a dictionary.

Explore Python packages and modules, organize files into a project structure with main and module scripts, and master imports to access variables and call functions across packages.

Learn practical Python error handling by validating input with input(), converting to int safely, and using try/except (with optional else and finally) to manage runtime errors.

Explore Python file i/o by opening files with read, write, and append modes, writing and reading content, and closing files while handling io errors.

Explore robust io error handling in Python by using try and except for file not found and io errors, creating missing files, and differentiating FileNotFoundError from generic io errors.

Learn to build a first port scanner in Python from scratch, using socket for TCP connections, arg parsing, ASCII banners, and basic open-port detection with practical safety notes.

Develop and test a web directory discovery tool in Python using the requests library, reading directories from a file, building full URLs, and handling connection errors.

Develop a python brute login script using rockyou.txt, sending post requests to a target url, iterating passwords, handling login failures, and adding colored output to visualize progress ethically.

Explore EC2, Amazon's elastic compute cloud, with pay-as-you-go on-demand pricing, spot, saving plans, reserved, and dedicated hosts. Learn burstable t2/t3 instances with CPU credits and diverse instance types.

Master identity and access management (iam) concepts by exploring users, groups, policies, roles, and multi-factor authentication with aws iam in real-world hands-on practice.

Learn how users access AWS through the AWS console, the CLI, and the SDK, with a practical overview of console login and upcoming lessons on creating users and credentials.

Create IAM users and groups, assign programmatic and console access with a downloadable CSV file of credentials, and attach policies to control EC2 and other services.

Learn to enforce a strong IAM password policy in AWS by setting minimum length, uppercase and lowercase requirements, numbers, ninety day expiration, and no password reuse, with admin reset.

Learn how to read and create IAM policies in AWS, understand statements, actions, effects, resources (including EC2 and ARN), and attach policies to users or groups.

Enable multi-factor authentication by setting up a virtual MFA for credentials and scanning QR code with a mobile authenticator, and assign MFA to root and IAM users for best practice.

Explore how to install and configure the AWS CLI across Linux, macOS, and Windows, run common commands like describe instances and security groups, and manage credentials securely.

Explore AWS cloud shell with pre-installed tools and storage, accessible from the AWS console. Run AWS CLI commands like describe security groups directly in cloud shell.

Create an IAM role with an EC2 trust relationship and attach a policy granting S3 full access to a specific EC2 instance.

Explore access advisor insights to see which services a test user can access and when, review IAM policies and last access, and generate a credential report for auditing.

Explore Amazon EC2, a secure, scalable cloud compute service, covering on-demand, spot, reserved and savings plans pricing, instance types, and usage scenarios.

Launch an EC2 Ubuntu 20 LTS instance (t2 micro, AWS free tier), create a key pair, and connect over SSH while avoiding root and using an IAM user.

Connect to an EC2 instance using instance connect, verify network access with ifconfig after installing net-tools, and add a name tag to identify the instance.

Assign an instance profile IAM role to an EC2 instance to grant secure S3 access, turning the instance into a trusted entity with full S3 permissions while avoiding public exposure.

Explore EC2 placement groups and cluster, partition, and spread strategies for low latency, high throughput, and fault tolerance. Learn when to apply each pattern and their key limitations.

Learn how to create and configure an EC2 placement group, choose a strategy (cluster, spread, partition), and add instances, noting cluster groups are not supported by T2 Micro.

Learn how EC2 hibernation suspends RAM to the root EBS volume and resumes processes on restart. Explore requirements like supported linux AMIs, T2/T3 instances, and encrypted volumes for optimal hibernation.

Examine elastic network interfaces in VPC, including primary and secondary IPs, elastic IPs, and IPv6 addresses. Learn to create, assign, and attach ENIs to EC2 instances with subnet options.

Explore EC2 spot instances and spot requests, review pricing history by region and availability zone, and configure fleet settings for load balancing workloads.

Explore elastic block store (EBS) for EC2, comparing SSD and HDD volume types, pricing, and use cases from boot volumes to high performance databases.

Learn to create and manage elastic block store volumes in the EC2 console, including volume types, encryption with the KMS key, snapshots, attachments, and lifecycle policies.

Learn to create and use an AMI to launch instances with root volumes from the operating system and applications, including launch permissions, block device mappings, and EBS snapshots.

Create an AMI from a configured Ubuntu 20 EC2 instance to preinstall tools like net-tools, then launch new instances from the AMI for immediate ready-to-use deployments.

Explore elastic file system, a simple serverless storage with five gigabytes of standard storage free for 12 months, and learn to mount it to EC2, ECS, EKS, Fargate, and Lambda.

Perform a hands-on setup of an AWS elastic file system (efs) in a one-zone VPC, configure optional backups and performance, and mount via DNS or NFS with fstab for startup.

Explore auto scaling groups as a logical collection of Amazon EC2 instances and configure health-based scaling policies using launch configurations.

Configure a launch configuration for an auto scaling group using a golden army (ami), selecting instance type, security groups, IAM role, spot options, and optional monitoring.

Create an auto scaling group with a launch configuration, configure health checks and subnets, and apply a CPU-based scaling policy monitored by CloudWatch.

Elastic load balancers distribute traffic across targets to ensure high availability across multiple availability zones. Choose app, network, or classic types for http/s, tcp/udp, or basic balancing, with pricing examples.

Learn to create and configure a classic load balancer in EC2, set its listener protocols, health checks, and security groups, and optimize cross-zone load balancing and connection draining.

Configure a network load balancer for high performance with TCP/UDP, TLS offloading, centralized certificate deployment, static IPs, and millions of requests per second in internet-facing VPC subnets for high availability.

Configure an application load balancer for http and https traffic with advanced routing for microservices and containers, including ACM or IAM certificates, subnets, VPC, and health checks.

Explore AWS VPC basics and components—virtual private cloud, subnets, route tables, gateways, security groups, and NAT gateways—through practical, step-by-step DevSecOps scenarios.

Create your first VPC in the VPC console by selecting a custom IPv4 CIDR block (commonly /16), then review the default VPC and public/private subnet options.

Create public and private subnets in a vpc, configure ipv4 cidrs and auto assign public ip. Launch public and private ec2 instances and note internet gateway and elastic ip behavior.

Elastic IP addresses provide a static public IPv4 address for dynamic cloud computing, allowing you to allocate them and associate with an EC2 instance or network interface in a VPC.

Discover how to create and manage VPC route tables, associate public subnets, and configure routes to an internet gateway, with attention to main, custom, and propagation concepts.

Describe how a NAT gateway in a public subnet lets private subnet instances access internet while preventing inbound connections, including elastic IPs and route tables, plus bastion or VPN access.

configure an ipv6 egress-only internet gateway to enable outbound ipv6 traffic from vpc instances, with a dedicated ipv6 route table for routing.

Explore how VPC network ACL provides an optional firewall layer with rule-based traffic control, where lower numbered rules have higher priority for inbound and outbound traffic, and subnet associations.

VPC peering connects two VPCs to route traffic via IPv4 or IPv6, even across AWS accounts, with a requester and acceptor workflow and optional DNS resolution settings.

Understand that an internet gateway is a horizontally scaled, redundant vpc component enabling internet access, targeting traffic in route tables and performing nat for public ipv4, with ipv6 support.

Discover AWS Route 53 as a reliable, cost-effective DNS provider for domain registration and traffic routing, including latency-based routing, health checks, monitoring, and DNS records such as alias.

Register a domain on Route 53 by selecting a TLD, checking availability, and adding to cart with privacy protection and renewal options; then manage DNS and hosted zones.

Create and manage Route 53 hosted zones, public or private, tied to a VPC, with alias records to AWS services; apply routing policies for private domains.

Learn to configure Route 53 health checks that monitor endpoints worldwide, using IP or domain, http/https/tcp, path and port, and optional string matching for health verification.

Explore ci/cd concepts including continuous integration, automated builds and tests, and the differences between continuous delivery and continuous deployment, plus the role of culture and monitoring in deployments to production.

Jenkins is a self-contained open source automation server that automates building, testing, and delivering software. Install via native packages, Docker, or standalone with Java, and use plugins for CI.

Install Jenkins on Ubuntu 18 in an AWS EC2 instance, with Java 8 setup, repository configuration, and initial unlock. Enable service, install recommended plugins, and create an admin user.

Create a new Jenkins job by naming it and selecting a project type, such as freestyle or pipeline. Review configuration areas: settings, source code management, build triggers, and build actions.

Configure Jenkins jobs with descriptions, discard rules by age or count, log rotation and artifact retention, and parameterized builds with GitHub project links, rate limit, and concurrent execution.

Learn how to configure source code management with Git repositories, set repo URLs and credentials, manage multiple repos and branches, and explore advanced checkout and clone options for build triggers.

explore Jenkins job triggers, including remote builds via URL and token, downstream and upstream relationships, cron schedules, and the GitHub hook trigger, with polling and security notes.

Manage the built environment with a fresh workspace, control secrets and credentials for shell or PowerShell builds, set timeouts and timestamps, and inspect Gradle build logs for insights.

Configure a build job to deploy dependencies, build packages, and run commands (Unix shell, Windows batch, and Maven), while setting build status on GitHub commits and ensuring safety and performance.

Explore boss build actions after a Jenkins build, including aggregating downstream test results, archiving artifacts, publishing unit test results, and notifying via email, GitHub status, or Slack.

Create and manage multiple job views using list views, filters, and selected columns; name views like first and second, and arrange staging, production, and development jobs.

Explore Jenkins system information and properties, including Java home, user home, environment variables, plugins, memory usage, and components like the JWT toolkit and executable war.

Configure the global tool configuration to manage maven settings and a default global settings provider, then add and install jdk, git, gradle, and maven for all projects.

Learn to access and capture system and Jenkins logs, view log messages and levels, and use Manage Jenkins to troubleshoot via environment variables.

Explore configuring the Jenkins system, including executors, labels, quiet period, project naming, admin email, CSP and resource routing, environment variables, tool locations, and SMTP-based notification setup.

Manage Jenkins plugins by installing, updating, and uninstalling, handling dependencies, and configuring server and proxy settings, then set up the Slack notification plugin for post-build alerts.

Manage users in Jenkins by creating and configuring accounts, tokens, credentials, emails, descriptions, and time zones, while exploring Slack integration and the security lecture later.

Configure global security in Jenkins by selecting authentication options (Jenkins own user database or LDAP) and authorization methods (legacy, matrix, or project-based matrix), with master security and CSRF protection.

Explore managing Jenkins credentials across global and domain scopes, add GitHub credentials with username or private key, and secure node access with SSH key and passphrase.

Master Jenkins controls slave nodes, configuring executors, labels, and remote roots; securely add Ubuntu nodes via SSH with credentials, ensuring connectivity and proper launch methods.

Explore how Docker uses os-level virtualization to deliver software in portable containers and images that run the same on machine, enabling microservices, legacy apps, machine learning deployment, and gpu support.

Understand docker’s client–server architecture, where the client communicates with the daemon on a docker host to pull images from a registry such as docker hub and run containers.

Explain the difference between virtual machines and containers, detailing how VMs use hypervisors with guest OSes while containers share the host OS kernel, and compare performance, isolation, and resource use.

Install Docker on Linux by choosing Ubuntu, updating packages, adding the official GPG key, and installing Docker CLI and container; verify the daemon with sudo docker version.

Install docker on mac by downloading Docker Desktop for Mac from Docker Hub and installing the DMG package. Enter privileged access and verify with docker --help and docker version.

Explore docker basics, including the Docker engine, daemon, and client, along with networks, containers, images, and data volumes. Grasp differences between images and containers before practical sessions.

Understand Docker engine as a client–server application consisting of the Docker daemon, REST API, and the CLI; the daemon manages images, containers, networks, and volumes.

Explore docker images as read-only templates for containers, built from images like Ubuntu, with apps and configurations, and learn about intermediate layers, caching, and options like --all and --quiet.

Create and manage docker containers as runnable instances of images using the Docker CLI or API, connect to networks and storage, and distinguish containers from images while practicing common commands.

Learn how docker storage works, including the writable container layer, and when to use volumes, bind mounts, and tmpfs to persist, share, or secure data across containers.

Explore Docker networking drivers, including bridge, host, overlay, macvlan, none, and third-party plugins, and learn when to use each to enable container communication, swarm services, or legacy workloads.

Explore an overview of essential docker commands, from docker help to operations like run, attach, build, logs, ps, and remove, with emphasis on real-world usage and theory.

Explore Dockerfile basics, a text document that contains commands to build custom images with docker build, including examples and the role of docker ignore and future Docker Compose.

Learn how docker compose defines and runs multi-container docker applications using yaml to configure services, volumes, and ports with a single docker-compose up command.

Run your first docker container with the hello world image, pull it from docker hub, and explore containers and images using docker ps, docker images, and help options.

Learn to run and manage an Ubuntu container with Docker run, using interactive (-it) and pseudo-tty options, attach, and background running in a DevSecOps context.

Manage the container lifecycle with docker start, stop, and kill; track status with docker ps and docker ps -a, and automate cleanup with docker rm via the quiet option.

Manage docker images by removing unwanted ones with docker rmi using image IDs, optionally forcing removal, then pull from registry and push to docker hub after logging in.

Learn to run an nginx container from the nginx image in daemon mode, publish port 8080 to 80, and verify by visiting localhost.

Learn to run Nginx in a docker container with port publishing and bind mounts, mapping a host directory to Nginx's html folder to serve live, editable content.

Master Dockerfile basics by defining from and run instructions, exploring cmd and entrypoint behavior, and learning to build, tag, run, and remove images and containers.

Explore dockerfile add instructions to copy test one and test two from the host into the container, create a work directory, and verify with build and run commands on Ubuntu.

Explore Docker compose, YAML-based tool to define and run multi-container applications from a YAML file. Automate development, testing, and staging with isolated environments, preserve volume data, and recreate changed containers.

Explore yaml syntax, showcasing human-readable key-value pairs, lists with dashes, and two-space indentation. Learn through docker-compose examples, including version, services, web, redis, and volumes.

Create a simple Python Flask app in a new directory, write app.py with a hello world route and a refresh counter, and prepare a requirements.txt for dockerized deployment with Redis.

Write a Dockerfile to build a Python app image with Alpine, set up workdir, configure environment variables, install dependencies from requirements.txt, expose port 5000, copy sources, and run the app.

Create a docker compose file to build a web and redis stack, define version and services, configure build context and port 5000, and spin up the infrastructure with one command.

Spin up the whole infrastructure with a single Docker Compose up command, inspect images, run containers, and verify Flask app on port 5000 with logs and development server behavior.

Map the host code via a docker compose bind mount, updating app.py reflected in the container without rebuilding, by configuring volumes in docker compose.

Master docker compose basics: up and down, run in background with -d, and inspect environment variables for the web service.

Explore how Docker containers bundle applications with dependencies, run as isolated runtime instances on a shared kernel, and use images, Docker files, and compose for portable deployments.

Discover how to use Docker info to inspect host details, operate up, run, and start commands, and grasp Docker compose, Dockerfile basics, and logging for real-world DevSecOps interviews.

Explore Json and Yaml for docker compose, run docker compose up with Json, and manage container lifecycle, dependencies, and environment-specific docker compose files across dev, staging, and production.

Kubernetes enables management of containerized workloads and services on an open source platform with declarative configuration and automation, offering self-healing, automated rollouts, service discovery, load balancing, and storage orchestration.

Understand how a Kubernetes cluster uses a control plane and nodes, with components such as API server, etcd, scheduler, and cloud controller manager, plus kubelet and kube proxy on nodes.

Create a Kubernetes cluster using minikube on Ubuntu, installing VirtualBox, kubectl, and minikube, then start and verify the cluster's control plane and nodes.

Deploy an app on a Kubernetes cluster by creating a deployment with a BusyBox image. Verify readiness with kubectl get deployments and access via kubectl proxy and curl.

Explore your app by inspecting kubectl pods, describing the deployment, viewing logs, and using exec to access the container; identify readiness and IP details, inspect server.js, and test in browser.

Expose your deployment publicly by creating a nodeport service on port 8081, then access it via the minikube IP and the assigned external port.

Scale up your app using kubectl scale deployment to three replicas, then scale down, highlighting imperative vs declarative approaches.

Explore core concepts of kubectl workflow, including namespaces, pods, services, jsonpath queries, yaml manifests, and lifecycle tasks like create, update, describe, logs, and delete.

Create and manage multi-container pods using busybox and sidecars with kubectl, yaml configurations, and logs, exec, and curl verification. Learn to collect metrics and verify logs with a sidecar nginx.

Learn to design and manage pods with labels in kubectl, apply env-based selection for dev and prod, and deploy, scale, and rollout web apps using nginx.

Learn to implement state persistence in Kubernetes by creating and using persistent volumes and claims with HostPath, storage class manual, and YAML, then verify data across pods.

Explore hands-on Kubernetes configuration tasks, creating and managing config maps, secrets, and environment variables, deploying nginx and busybox pods with volume mounts and security contexts.

Explore observability by creating nginx pods on port 80, configuring readiness and liveness probes, and verifying health endpoints with kubectl, logs, and events.

Learn to deploy and expose an nginx service in Kubernetes, label pods, create and test services (NodePort), and implement a default deny ingress network policy.

Explore infrastructure as code (iac) to manage data centers via machine readable definitions, writing code that builds infrastructure. Compare cloudformation and terraform, noting aws integration and cloud-agnostic benefits.

Leverage CloudFormation to model infrastructure as code and automate resource provisioning. Define templates in yaml or json, deploy stacks via console or CLI, and manage drift, cross-account and cross-region resources.

Learn the basics of YAML syntax, including key-value pairs, indentation, and lists, then apply them to define resources, properties, and parameters in DevSecOps workflows.

Learn how to create a CloudFormation stack by selecting or uploading a template, deploy a simple EC2 instance in us-east-1, and configure rollback and basic notifications.

Update and delete a CloudFormation stack by uploading a new template, editing in the designer, and applying parameters to configure elastic IPs, security groups, and intrinsic function references.

Learn to use CloudFormation parameters to customize templates with input values for stack creation or updates, including defaults, allowed values, and the ref intrinsic function in YAML.

Define CloudFormation resources in YAML, including the resources section, logical IDs, types, and properties. Explore EC2 and other resource types, and consult the official AWS CloudFormation docs.

Learn how CloudFormation mappings use region-based keys and the find in map intrinsic function, including exclamation mark syntax and hard-coded values.

Explore how CloudFormation outputs enable cross-stack references by exporting values like S3 bucket names and VPC IDs, and importing them with import value while respecting regional and security constraints.

Define and apply cloudformation conditions to create resources and outputs only when true. Tailor templates for test or prod using parameters, region maps, and intrinsic functions.

Learn how CloudFormation intrinsic functions assign runtime values in templates and apply them to resource properties, outputs, metadata, and update policies to conditionally create resources.

Explore CloudFormation user data that installs Apache via yum, encodes commands in base64, and writes outputs to cloud-init logs while using an SSH key and opening port 80.

Explore CFN init as a powerful alternative to user data for complex setups, reading template metadata from the CloudFormation init key and installing packages, writing files, and managing services.

Learn to use the CloudFormation cfn signal to mark EC2 creation success and signal readiness after bootstrap, with a two-minute wait and a creation policy.

Explore CloudFormation rollbacks, including enabling or disabling rollback, how timeouts and termination protection influence stack creation, and how rollback returns to the previous template for investigation without deleting resources.

Explore AWS CloudFormation nested stacks by creating a dedicated load balancer template and referencing it from parent templates, clarifying root, parent, and nested relationships for scalable deployments.

Learn how CloudFormation change sets let you preview changes to a stack before execution, safely updating running resources such as EC2 instances, security groups, and IP addresses.

Learn how the CloudFormation dependsOn attribute enforces creation order by making an EC2 instance depend on a MyDB instance, with a YAML example using MySQL 5.7 and a deletion policy.

Detect drift in CloudFormation stacks against templates, view drift results, and identify modified resources such as security groups and inbound rules to support automation.

Learn how infrastructure as code uses machine readable definitions to provision data centers. See how Terraform builds, changes, and versions infrastructure across providers, including AWS, Heroku, and multi-cloud setups.

Install Visual Studio Code, a free, supported text editor, from code.visualstudio.com and prepare a folder for your Terraform environment.

Create a Terraform project folder in Visual Studio Code, then add a main.tf file inside a dedicated Terraform directory to organize your Terraform workflows.

Create your first terraform resource by defining a main.tf with an aws provider, a my vpc aws_vpc, and cidr block 10.0.0.0/16, then prepare for initialization, planning, applying, and destroying.

Install Terraform on ubuntu linux by adding the official HashiCorp repository, importing the GPG key, and updating the package list, then install and verify with Terraform --help.

Create a Terraform IAM user with programmatic access, generate an access key and secret access key, assign a policy (avoid administrator access in production), and securely download credentials.

Learn to regenerate access keys by opening the security credentials tab, create and download new keys, toggle active or inactive states, and delete keys as needed.

Learn how to initialize a Terraform project with terraform init, which downloads and installs provider plugins (such as the AWS provider) and sets up the Terraform directory and providers registry.

Generate and review a Terraform execution plan to see proposed adds, changes, and destroys; learn to fix credential errors and adopt environment variables or AWS parameter store for secure access.

Apply Terraform to provision an AWS VPC, review the Terraform state file, and verify the new VPC is created, laying groundwork for future EC2 and RDS topics.

Destroy the VPC with the Terraform destroy command to see how infrastructure as code enables fast, disposable environments, built and torn down in seconds, cloud agnostic across providers.

Explore the Terraform state file, the heart of Terraform, which tracks your infrastructure across apply and destroy, including tfstate records of a VPC and its cidr block.

Learn to define Terraform variables in a dedicated variables directory, creating a main.tf, and specify a string type with a default value.

Define boolean variables in Terraform by omitting the type and setting a default value, typically true, to represent flags like is enabled that can be true or false.

Learn how to define Terraform list variables, specify their type (string, number, boolean), and set default values using square brackets, with strings requiring quotes and mixed types forbidden.

Declare a terraform map variable with a default like key1=value1 and key2=value2, noting that keys are case-insensitive. The lesson defines string, number, boolean, list, and map variables, with use explained.

Learn to use a string variable in Terraform to configure an AWS VPC, set cidr_block, and tag the VPC with a name value from var.my_string.

Learn to define a list variable, distinguish string and number elements, and access items by index (0 for Apple, 1 for 20) using quotes.

Learn how to define a map variable in Terraform, assign key-value pairs with square brackets and quoted keys, and retrieve values by keys such as key one and key two.

Learn how Terraform input variables drive interactive prompts, including defining a string type, optional defaults, and descriptions, then apply to provision an AWS VPC with a name from user input.

Master Terraform outputs by declaring an output and returning the VPC ID, name, and CIDR block after apply.

Explore how to declare and use table and object variables in Terraform, defining key-value pairs and a default value, with name as string and port as a list of numbers.

Create an AWS EC2 instance with Terraform by configuring provider, ami, and instance type in Main.tf; handle default VPC, run terraform init and apply, then destroy when finished.

Allocate an elastic IP to an EC2 instance using Terraform, defining aws_ip and outputting the public IP. Plan, apply, and destroy resources to manage the elastic IP lifecycle.

Learn to create and configure an aws security group with Terraform, defining ingress and egress rules for https traffic, using cidr blocks and applying to ec2 instances.

Discover how Terraform modules simplify infrastructure by reusing local and remote modules, organizing code with main.tf and an EC2 module, and applying provider blocks and resources across regions.

Learn to define and access Terraform module outputs to expose an EC2 instance ID from a module to the main configuration and verify it with Terraform apply.

Learn how to use remote modules in Terraform by leveraging the official registry to deploy common infrastructure like AWS VPCs and security groups, without rewriting configurations.

Create an IAM user with Terraform, define a custom policy, and attach it to the user via a policy attachment. Apply, verify it is attached, then destroy to clean up.

Develop and deploy an AWS RDS instance with Terraform, configuring MySQL 5.7 on a db.t2.micro with gp2 storage and skipping final snapshot while managing credentials and region in AWS provider.

Configure a remote backend with an S3 bucket to store the Terraform state file, enable versioning and block public access, then use it for plan and apply in Terraform Cloud.

Learn how to configure a remote terraform backend with S3, initialize, apply, and destroy a VPC, and manage tfstate in an S3 bucket.

Use the count feature in Terraform to create multiple EC2 instances from a single resource block with an AMI ID, then run Terraform apply to provision them.

Learn how to import existing AWS VPC resources into Terraform using Terraform import, align the CIDR block, and update the state file, then manage and destroy both resources.

Learn how to enforce resource order in Terraform using the depends_on attribute, ensuring the database is created before the web server, with destroy order reflecting dependencies.

Learn how Terraform data sources fetch or compute information for use in configurations, such as locating the latest AMI by tag and returning its availability zone.

Learn how to use Terraform validate to check syntax in Terraform configuration files, identify common mistakes such as missing newlines or missing equals signs, and ensure validity.

Learn to use Terraform fmt to format Terraform templates, transforming chaotic configuration files into elegant, consistently styled code for team-wide consistency.

Learn how to manage multiple aws providers in terraform using aliases to deploy resources across regions such as us-west-2 and us-east-1, with region-specific ami IDs and provider blocks.

Master Terraform's remote-exec provisioner to connect via SSH to an EC2 instance using a key pair, install nginx, and start services.

Set up a local-exec provisioner in Terraform to write the EC2 private IP to private_ip.txt and verify it matches the AWS console.

Learn to use Terraform plan with destroy to preview what will be destroyed for a VPC and its CIDR block. Apply and run destroy to verify the state.

Manage multiple Terraform workspaces to isolate staging and production environments using create, list, select, show, and delete commands. The lecture demonstrates creating env one and switching between workspaces.

Learn how to use Terraform taint to force recreation of a tainted resource. See how tainted resources are marked and how apply replaces them, such as a VPC.

Explore TerraForm built-in functions, from max, numeric, absolute, and floor to string, collection, networking, date, file system, and cryptography utilities, and learn when to apply them across use cases.

Enable terraform debugging by exporting the TF_LOG variable to trace, debug, info, warn, or error, and optionally set TF_LOG_PATH to save verbose logs for terraform plan analysis.

Explore how to mark outputs as sensitive in Terraform, hide CIDR block details in plan output, and understand why sensitive values still appear in the state file.

Master Terraform basics for devops by learning infrastructure as code with the Hashicorp language, AWS and Azure integration, and essential commands like init, plan, apply, and destroy.

Explore Terraform interview prep, focusing on Terraform Cloud, backends, and state management. Understand version control options (GitHub, GitLab, Bitbucket), Terraform CLI basics, modules, and Oracle Cloud infrastructure.

Master terraform interview prep by handling duplicate resource errors, using terraform import, and managing version control with Azure DevOps, GitLab, Bitbucket, and GitHub. Highlight built-in provisions and sensitive data practices.

Explore how a thin wrapper keeps Terraform configuration dry and manages remote state across multiple accounts. Lock state to prevent conflicts and taint resources to trigger rebuilds on next apply.

Explore Amazon CloudWatch for monitoring and observability across AWS and on-prem resources, delivering metrics, logs, and events with alarms and automated actions to optimize performance.

Explore AWS CloudWatch default metrics for resources like EC2, EBS, and S3, enable detailed or custom metrics, and visualize data with dashboards across regions and timeframes.

Publish custom metrics to CloudWatch using the AWS CLI or API, view statistics in the console, and learn how to structure metric data points, dimensions, and statistic sets.

Learn how CloudWatch alarms use metric and composite alarms to monitor metrics like CPU utilization, configure thresholds, evaluation periods, and missing data handling, and trigger notifications, autoscaling, or EC2 actions.

Learn how to monitor AWS estimated charges with CloudWatch billing alarms, including setting thresholds, currencies, and alert actions for consolidated billing across linked accounts.

Explore how CloudWatch Logs centralizes, monitors, and stores logs from EC2, CloudTrail, Route 53, and more, with search, filtering, retention controls, and archiving.

Push custom Apache and Nginx logs to CloudWatch using the unified agent, configure log groups and streams, and monitor memory and disk metrics on EC2 or on-prem.

Create metric filters in CloudWatch from log groups and custom logs to detect errors and trigger alarms if counts exceed threshold; escalate to security and operations teams.

Leverage CloudWatch events (EventBridge) to automate responses using rules, event patterns, and targets such as Lambda, SNS, or SQS for EC2 and S3 events.

Learn to use CloudWatch dashboards to monitor resources across multiple regions and accounts from a single, customizable view with graphs and alarms, including multi-region, multi-account setups.