DevOps Uncomplicated: Hands-On Automation

Explore cloud computing with AWS and Azure for DevOps, focusing on virtual machines and storage like S3 and blob storage, with automation via CLI and infrastructure as code.

Explore virtual networks (VPC and VNet), security rules, and managed containers (AKS and ECS), then implement monitoring with CloudWatch and Azure Monitor, and automate with Terraform and GitHub Actions.

Manage access in AWS by configuring IAM, enabling MFA on root, creating admin users and groups, and applying least-privilege permissions for secure automation.

Create an AWS EC2 instance via the console, attach a key pair for SSH, configure a security group, and use user data to install nginx on boot.

Create and configure a basic AWS VPC network using the portal wizard, including public and private subnets, an internet gateway, a NAT gateway, and route tables for controlled internet access.

Navigate the Azure portal, claim a free account with $200 credit for 30 days, and learn to organize resources with resource groups and cloud shell.

Create a virtual machine in Azure via the portal, access it with SSH, and compare manual setup to automation, including resource group, region, Ubuntu, port 22, and cost estimates.

Store log files and tf state in an Azure storage account container for automation pipelines, then practice provisioning and deleting to avoid costs.

Master the Linux command line for automation by navigating directories, managing files, and viewing logs to empower scripts, containers, and cloud workflows in DevOps.

Explore Linux automation concepts, including permissions, environment variables, and script structure; learn to build dynamic shell scripts with chmod, sudo, variables, conditionals, loops, and logs.

Explore hands-on linux directory management in the terminal, using mkdir -p, cd, and pwd to create and navigate folders, and touch, cp, mv, and rm for file operations and automation.

Manipulate file contents with practical terminal commands to read, search, substitute, and compare text, work with text columns, and support pipelines and log analysis.

Learn to monitor system health with commands like top, ps, and grep, manage memory and disk usage, track uptime and logged-in users, and safely kill, shutdown, or reboot.

Master Linux file permissions and ownership by checking and modifying permissions, changing owner and group, and using chmod and chown to secure scripts and files.

Learn Linux package management across Ubuntu, CentOS, and Fedora by installing, updating, and removing software in the terminal, including containers and Docker contexts.

Install Git on your machine, verify the version, and configure global user name and email so all commits include author information as you begin the hands-on labs.

create and clone a repository, generate an ssh key, and configure secure ssh access to a remote git host for seamless command-line collaboration.

Learn to initialize a git repository, check status, add and commit changes, push to the repository on the main branch, and create a readme using markdown to document your project.

Create a feature branch from main, commit Terraform files, push to a remote, and manage a GitHub pull request to merge changes from feature to develop to main.

Practice using git pull to update your local branch from the remote, keep it in sync with main and developer, and avoid conflicts.

Create a custom terminal function named d to automate git add, commit with a default message, and push with a single command, saving time and reinforcing daily devops workflows.

Master hands-on Linux directory and file management in a Ubuntu environment, using mkdir -p, ls, touch, cp, mv, rm, rmdir, and pwd to create, list, copy, move, and delete directories.

Master manipulating file contents with simple terminal commands, such as reading, searching, substituting, and comparing in pipelines, log files, and text columns.

Master Linux system monitoring using top, ps ux, uname -a, and grep to identify resource-heavy processes. Learn to kill, check disk and memory, and perform shutdown or reboot for automation.

Learn Linux file permissions and ownership, including checking, modifying, and setting owner and group with chmod and chown. Apply common permission sets like 755 and 644 and make scripts executable.

Learn to install, update, and remove Linux packages across Ubuntu, CentOS, and Amazon Linux using apt, yum, and dnf; manage repositories, dependencies, and security.

Install Docker on Ubuntu using apt, update certificates, and add the Docker repository to install the latest version. Complete post-installation steps to run containers without sudo.

Learn to pull images, run containers in the background, map ports, securely access containers, test with curl, and clean up by removing containers and images using essential docker commands.

Create a lightweight Python docker image with a Dockerfile, install requirements, copy code, and run FastAPI via Uvicorn on port 8000 to test a containerized API.

Master production-ready Docker images with multi-stage builds in Node.js, swapping a heavy build stage for a slim runtime image using node 18 and alpine.

Create a .gitignore to prevent sensitive and temporary files from entering your repo, protecting credentials and private data, including env files, while ignoring large folders like node_modules to boost performance.

Push Docker images to Docker Hub by tagging builds, authenticating with Docker login, and pushing to a public registry, then pull and run images from anywhere.

Orchestrate multiple containers with Docker Compose to run a node app and a PostgreSQL database, creating a reproducible development environment with a single configuration file.

Gain hands-on experience with the Azure CLI by logging in, listing resource groups, and viewing virtual machines to prepare for automation in GitHub Actions and pipelines.

Create two virtual machines with Azure CLI, configuring a DevOps automation resource group, Ubuntu 22.04, and admin credentials. Retrieve IPs and essentials, then delete the resource group to avoid charges.

Convert manual Azure CLI VM creation into a Bash automation script for bulk deployment, using a resource group, a create-vm function, a VM list loop, and no-wait provisioning.

Learn to extract Azure vm data in json using az cli, aws cli, and jq, with simple text tools. Capture vm names, public ips, and status for automation workflows.

Configure the aws cli, manage s3 buckets, provision ec2, and manage iam permissions from the command line using json outputs to automate devops.

Learn to create an AWS instance with the AWS CLI, using the default VPC, handle JSON outputs, configure a key pair and security group, and connect via SSH for cleanup.

Automate bulk AWS VM creation with a bash script and the AWS CLI, using loops and variables to fetch VPC, subnet, and AMI, then deploy, tag, and enable SSH access.

learn how to create an azure resource group with terraform by configuring provider and main files, initializing, validating, planning, formatting, and applying the first deployment.

Create an Azure VM with Terraform by defining provider, variables, and data sources, reusing an existing resource group and building main.tf and variables.tf for automation.

Continue building a Terraform configuration to provision an Azure virtual machine by creating the virtual network, subnet, public IP, and network interface in the same resource group.

Create an Azure Linux virtual machine using a resource block, configure admin credentials, and disable password authentication. Link the network interface to a security group with SSH and 8081 rules.

Continue building an Azure virtual machine with Terraform, exposing outputs for the VM name and public IP, and managing resource groups, network interfaces, and plan–apply–destroy cycles.

Create a Kubernetes cluster with Terraform by provisioning infrastructure in Azure, configuring the Kubernetes and Helm providers, and authenticating with kubeconfig using base64 decoding.

Define variables and a main.tf data block to deploy an AKS cluster with a two-node default pool in Terraform, and explain Azure’s two resource groups and control plane separation.

Configure Terraform outputs for cluster access and ingress, then deploy Keda and ingress with Helm, creating namespaces and using values to customize a load balancer setup.

Create and validate an Azure Kubernetes cluster with Terraform, provisioning Kubernetes, Helm, and Azure providers, configuring node pools, ingress, and public IPs, then destroy resources to avoid charges.

Set up two Ubuntu VMs in Azure, designate a controller and a target, enable SSH ports 22 and 881, and prepare an environment for Ansible installation and testing.

Connect to the controller machine, install Ansible on Ubuntu, configure hosts and SSH, then verify connectivity with a ping test and run your first playbook.

Create your first Ansible playbook to configure a VM with packages and update the package cache, installing git, curl, and htop, then validate with a shell task showing htop version.

Deploy a Java application in Docker with an Ansible playbook, installing Docker, running the app on port 8081, and validating via Swagger, then automate via Terraform and GitHub Actions.

Master hands-on Ansible automation by managing users with playbooks and modules, creating users, directories, and log files, and validating permissions with shell commands and host targets.

Delete the lab environment by removing all resources and the resource group with az group delete to prevent lingering costs, and automate cleanup with Terraform and Ansible in GitHub Actions.

Set up a local workspace and a GitHub repository, configure SSH keys, and push the initial readme. Create a hello workflow in .github/workflows triggered on main that echoes a success message.

Set up a Docker workflow by provisioning an Azure resource group and a container registry, cloning a Java API, and configuring GitHub Actions with secrets for building and pushing containers.

Create a GitHub Actions ci/cd pipeline for a Java Maven app that builds, tests, builds a Docker image, scans with Trivy, and pushes to Azure Container Registry for staging.

Set up base infrastructure for the pipeline by creating a clean Terraform and Ansible structure and provisioning a resource group, storage account, and blob container for tfstate.

Configure secrets in a DevOps automation pipeline by managing variables in the repository settings, reusing the ARM subscription ID, editing the admin password, and securing SSH access.

Configure Terraform to provision an Azure VM by completing main.tf, back end, variables, and outputs, including a VNet, static IP, and open ports 22 and 8081 for educational purposes.

Configure an ansible playbook to provision an ubuntu machine, install docker and dependencies, start docker, run a registry container on port 881, and open access via the public IP.

Build a comprehensive deploy YAML pipeline with Terraform validate and plan, infrastructure tests, and a safe destroy option, enabling manual execution and secure Azure login via OIDC.

Launch and implement the full deployment pipeline with Terraform and Ansible to provision, configure an Azure VM, capture outputs, and set up environment variables for subsequent steps.

Validate infrastructure health through cross-job data transfer, Azure login, and automated tests that verify Swagger availability, VM status, and port 81 NSG rule, with pipeline running only after deploy succeeds.

Validate the destroy flag on an Ubuntu agent by logging into Azure, installing Terraform, and running Terraform destroy --auto-approve to delete infrastructure when true, with production locks preventing accidental deletions.

Validate infrastructure and application by running tests in a DevOps pipeline, using Terraform and Ansible to deploy a containerized API, verify Swagger endpoints, and destroy infrastructure.

Run and validate the pipeline end-to-end in Azure, deploy with Terraform, and verify outputs like the NSG and IP, then install Ansible, update the OS, Docker, and verify port 8081.

Demonstrates a pipeline that automatically destroys Azure infrastructure built with Terraform, validating deployment steps while tearing down resources such as NSG, VM, and a network interface to avoid costs.

Create and provision an AKS cluster on Azure with Terraform, install ingress using Helm and Keda, and validate with kubectl and static IP checks.

Create and manage your first kubernetes pod using kubectl, write a pod manifest, apply it, inspect with describe, and expose via port-forward to test with swagger.

In this lab, create and manage a replica set using apps v1, define metadata and a pod template, and observe how Kubernetes maintains the desired pod count for availability.

Create and manage a Kubernetes deployment to run multiple pod replicas, perform controlled updates, and rollback with kubectl rollout when issues occur.

Expose your Kubernetes deployment to the internet with a load balancer service, mapping port 80 to 8081, and scale to five replicas for high availability.

Learn to isolate development, staging, and production within one Kubernetes cluster by creating separate namespaces, deploying the same app in each, and verifying isolation with kubectl commands.

Configure resource control in Kubernetes by setting requests and limits for CPU and memory to ensure predictable pod behavior. Learn to monitor usage with kubectl top in production.

Configure Kubernetes health checks using liveness and readiness probes in a Java app with actuator health, tuning initial delay, period, and failure thresholds to ensure self-healing and safe traffic routing.

Observe how Kubernetes scales a two-container deployment with an HPA based on CPU utilization, using a sidecar stress container, from 1 to 10 replicas, and learn load testing basics.

Expose your Kubernetes app using ingress with a dynamic domain, configure NGINX ingress, define host, path, and back end, and test via Swagger.

Implement Keda to enable Kubernetes event driven autoscaling using cron triggers, scaling pods from zero to a configured maximum within a time window for predictive scaling and savings.