Learn DevOps: Docker, Kubernetes, Terraform and Azure DevOps

Discover how containerization simplifies DevOps by standardizing deployment across Java, Python, and JavaScript microservices. Learn how Docker images enable consistent runtimes and streamlined infrastructure as code across environments.

Install and explore Docker basics, compare Docker to virtual machines, and learn Docker architecture and key concepts that underpin DevOps workflows.

learn to deploy java, python, and nodejs apps to qa with docker images, running the same docker command across languages for fast, error-free deployments.

Explore how Docker images live in a public registry like Docker Hub, organized into repositories and tags, and how containers run with port publishing on a bridge network.

Explore how to use Docker Hub to understand registry, repository, and tags. Learn to run multiple containerized apps—Node.js, Java, and Python—on distinct ports via containerization.

Launch containers in detached mode with docker run -d, then monitor logs via docker logs and follow with docker logs -f, using container ID substrings.

Explore docker images and containers locally, view running and exited containers with docker container ls and -a, then stop containers by partial IDs to manage ports.

Understand Docker's client–server architecture, where the Docker client sends commands to the Docker daemon, which manages containers and images, pulls from the registry, and maps container ports to the host.

Explore why Docker dominates: standardized packaging with Docker images, multi-platform support, and lightweight, isolated containers that run anywhere—from local machines to cloud platforms with Kubernetes.

Master docker image management by listing, pulling official images, searching for images, inspecting image details and history, and removing images only after stopping and removing related containers.

Explore essential Docker container commands, including run and ls, pause and unpause, stop vs kill with sigterm and sigkill, logs follow, inspect, prune, and basic bridge networking.

Explore docker system commands, monitor with docker stats, prune unused images and containers, and control resource usage with memory and cpu quotas to manage docker environments.

Import docker projects into Visual Studio Code by cloning DevOps Masterclass repo and opening projects folder; view hello world in Java, Node.js, Python, and currency exchange and currency conversion microservices.

Builds a Docker image for the Hello World Python project, uses a Python base image with Alpine Linux, installs Flask via pip, copies code, exposes port 5000, and runs launch.py.

See how a hello world python app image builds from python alpine base, copying files, running pip install -r requirements.txt, exposing port 5000, and launching rest api, revealing docker layers.

Learn how to push a Python app image to Docker Hub by logging in, tagging with your Docker ID, and using docker push to publish 0.0.2.release.

Build and push a Node.js docker image by using npm to install dependencies from package.json, run index.js on port 5000, and push the v2 tag to Docker Hub.

Learn to build a two-stage docker image for a Spring Boot HelloWorld Java API with Maven, copy the jar between stages, and push the image to a registry.

Discover how to build efficient Docker images by optimizing layer caching, separating dependencies from code, and leveraging npm and pip installs to speed up builds, pushes, and deployments.

Compare dockerfile entrypoint and cmd, showing how cmd is replaced by command line arguments while entrypoint remains fixed, and when to use each.

Explore how Docker enables microservices by containerizing apps into portable images, delivering consistent deployments, fewer environment issues, and scalable orchestration for DevOps.

Explore two microservices: currency exchange service and currency conversion service; learn how they communicate, configure service host via environment variable, and study their role in Docker, Kubernetes, and CI/CD.

Master running currency exchange and currency conversion microservices as Docker containers by pulling images from Docker Hub, naming containers, mapping ports 8,000 and 8,100, and running in detached mode.

Docker bridge networks prevent container communication; link the currency conversion and currency exchange services and configure the currency exchange service host environment variable to http colon slash slash currency exchange.

Learn how to connect microservices with Docker custom networking by creating a currency network and running currency exchange and currency conversion on it, enabling container-name communication.

Use docker compose to define and run multi-container applications in a simple yaml file, then launch all microservices with a single docker compose up command.

Explore docker compose in depth: run containers in detached mode, inspect networks, prune resources, and use compose commands such as up, down, events, config, images, ps, top, pause, and kill.

Review regularly to solidify memory, take notes on key concepts, review periodically every few days or weeks, and reuse notes as ongoing inspiration for future learning.

Explore how Docker standardizes packaging and deployment, then orchestrate scalable, self-healing deployments with Kubernetes on Google Kubernetes Engine, enabling zero-downtime releases and cloud-neutral operations.

Create a Google Cloud account and start your free trial with $300 credit by providing personal details, verifying your mobile number, and entering card and tax information.

Learn how Kubernetes manages cloud nodes with master and worker nodes to form a cluster, then create a Google Kubernetes Engine standard cluster by naming it and choosing a zone.

Explore the running Kubernetes cluster, learn fun facts like K8s abbreviation and helmsman logo, and understand how Kubernetes reserves CPU and memory across three nodes.

Connect to a Kubernetes cluster via Google cloud shell, deploy a docker image with kubectl, expose it as a load-balanced service on port 8080, and verify the endpoint.

Discover how pods, replica sets, deployments, and services orchestrate workloads in Kubernetes, guided by the single responsibility principle, using kubectl to inspect ports and deployments for scalable, zero downtime deployments.

Understand pods as the smallest deployable unit in Kubernetes, learn how a pod can contain multiple containers, share resources, and expose an IP, labels, and annotations within a namespace.

Learn how replica sets maintain a desired number of pods in Kubernetes, and how deployments scale to multiple pods using practical hello-world REST API examples.

Learn how a Kubernetes deployment performs rolling updates to upgrade from v1 to v2 with zero downtime, creating a new replica set, and shifting traffic to the new version.

Review how pods function as container wrappers and how replica sets maintain a desired number of pods tied to a release, while deployments enable rolling updates and controlled version upgrades.

Understand the need for a Kubernetes service. Ensure a permanent front-end IP and load balancing across pods, so the same URL stays available as pods are added or removed.

Explore the google cloud console's kubernetes engine ui, managing a hello_world_prest.api deployment with scaling, rolling updates, service exposure, and revision history, and compare ui actions to kubectl workflows.

Explore master node components, including etcd, kube-apiserver, scheduler, and controller manager, and how they store the desired state while worker nodes run pods with kubelet, kube-proxy, and Docker container runtime.

Explore why Google Cloud regions and zones matter for latency, availability, and data legality, and how deploying across multiple regions and zones boosts resilience and compliance.

Install and configure Google Cloud software development kit (gcloud) and kubectl to deploy from terminal, authenticate your Google Cloud account, set your project, and manage Kubernetes from your local machine.

Install kubectl on Mac, Windows, or Linux (via Homebrew), verify with kubectl version, and connect to the Google Cloud cluster using kube config.

Master kubectl rollout history and undo to manage deployment revisions, record change causes with set image, and tail pod logs to monitor rollouts.

Generate and edit Kubernetes deployment and service configurations in YAML/AML, save them to files, and apply changes with kubectl, demonstrating declarative management of the Hello World REST API.

Clean and consolidate Kubernetes yaml by moving the service into the deployment, back up the original deployment, prune unnecessary fields, and delete existing deployments and services.

Use a Kubernetes deployment YAML to create a Hello World REST API and its service, monitor with kubectl and watch, and apply replica changes with kubectl diff and kubectl apply.

Learn how Kubernetes deployments and services are defined in YAML, using labels and selectors to map pods, configure rolling updates, and manage image pulls, ports, and session affinity.

Configure mean ready seconds to give containers 45 seconds to start. Learn to use kubectl diff and kubectl apply -F deployment.YAML while curling to verify rollout.

Explore replica sets in depth by converting a deployment to a replica set, diagnosing errors, and observing how replica sets maintain pod counts and load balance, while deployments manage releases.

Configure multiple Kubernetes deployments mapped to a single service, use labels to route traffic to V1 or V2, and observe load balancing across ReplicaSets and pods.

learn to explore a Kubernetes cluster using kubectl to list pods and services across namespaces, filter by labels, sort by type or name, and view cluster info and top metrics.

Delete all resources tied to the Hello World REST API in Kubernetes, including deployments and services, leaving only the cluster IP service in the default namespace for the next microservice exploration.

Explore how two microservices—the currency exchange and the currency conversion—talk to each other in Kubernetes, using environment variables, readiness and liveness probes, and ports 8000 and 8100.

Deploy microservices to Kubernetes by applying deployment yaml files, create and expose currency exchange and currency conversion services, observe external IPs, and verify inter-service communication.

Kubernetes injects environment variables for each service at startup, enabling microservices to discover and talk to neighbors via host and port values.

Configure the http://currencyexchange host for the currency conversion service to enable reliable Kubernetes service discovery and inter-service communication.

Leverage Kubernetes automatic DNS for service discovery and free load balancing by using service names; adjust replicas to test routing between currency conversion and currency exchange services.

Learn how Kubernetes ConfigMaps provide centralized configuration for microservices across environments, storing the currency exchange host and injecting it into deployments.

Learn how to replace multiple cloud load balancers with a single Kubernetes ingress that routes currency conversion and currency exchange microservices via node ports, using an ingress.yaml to rewrite urls.

Learn how Kubernetes ingress routes requests to currency exchange and currency conversion through a single load balancer with frontend and backend mappings.

Learn how to delete a Kubernetes cluster to save free credits and reduce cloud billing, including selecting the cluster in Kubernetes Engine and confirming deletion.

Prioritize your wellbeing while pursuing DevOps learnings by getting adequate sleep, maintaining a balanced diet, and regularly exercising to reduce stress and boost brain function.

Learn how infrastructure as code automates provisioning and configuration across multiple environments and microservices using Terraform and Ansible, enabling consistent, error-free deployments through CI/CD with Jenkins or Azure DevOps.

Learn how Terraform, an infrastructure as code tool, provisions cloud resources such as virtual servers, storage, and databases, while software installation is handled by configuration management tools.

Start a Terraform project with AWS as provider, initialize with terraform init, download provider plugins, and configure main.tf with region and AWS resources such as IAM users and S3 buckets.

Create an AWS IAM command line user with programmatic access, assign Administrator Access, and download the CSV containing the access key ID and secret access key for secure backup.

Configure Terraform to use AWS credentials via environment variables AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, enabling secure access to AWS in us-east-1, and test by creating an AWS resource.

Learn to create an AWS S3 bucket with Terraform using a resource block, plan, and apply workflow, including globally unique names and the basics of S3 durability and availability.

Understand how Terraform compares desired, known, and actual state to refresh state and apply changes, enabling or replacing resources like an S3 bucket when configurations differ.

Explore using the Terraform console to query the current state, view S3 bucket attributes including versioning, and define outputs with terraform apply and refresh to see results.

Create an AWS IAM user with Terraform by defining the AWS IAM user resource, generating a plan, and applying it with a saved tfplan. Inspect outputs, ARN, and Terraform state.

Learn how Terraform updates an AWS IAM user name in place with a targeted apply, changing 'my IAM user' to 'my IAM user ABC updated'.

Explore how terraform.tfstate and terraform.tfstate.backup store the known state, including the IAM user and S3 bucket, and why a known state is essential for proper plan and apply.

Avoid committing terraform.tfstate, tfstate.backup, or .terraform to version control; they may contain sensitive information. Use a remote backend (e.g., an S3 bucket) to share Terraform state across developers.

Refactor your Terraform setup by moving outputs to outputs.tf and splitting configuration across multiple .tf files, then run plan and apply to confirm no changes while exploring Terraform state types.

Create a Terraform project to provision multiple AWS IAM users using count and index-based names, then run init, plan, and apply to scale from two to three users.

Explore essential Terraform commands in the console, including validate, format, show, plan, and apply, and manage state and plan files with options like auto-approve and target.

Recover quickly from Terraform errors by applying fixes and correcting resource names after a failed apply. State refresh happens in parallel, updating the IAM user only.

Discover how to create and use Terraform variables, set defaults, and override values via environment variables, terraform.tfvars, or the command line, with type checks and environment use for different environments.

Learn how to create a Terraform project that uses a names list to dynamically create users in parallel, using var.names.length and var.names[count.index], and explore list functions.

Learn how adding a value to a Terraform list triggers changes based on index keys, and how converting to a set and using for_each yields stable, value-based updates.

Create and manage Terraform maps and map of maps, read values, and apply changes using for_each with country and department tags.

Explore Terraform FAQs on state, including why we need state, the mapping of Terraform objects to cloud resources, dependencies, and tfstate's role in performance.

Understand how EC2 creates virtual servers in the AWS console, including regions, VPC, and subnets. Explore AMI choices, instance types, and security groups, and preview automating EC2 creation with Terraform.

Learn how to create a new Terraform project for AWS EC2 instances by defining a security group with HTTP and SSH access, configuring CIDR blocks, a VPC, and applying changes.

Create and securely store an EC2 key pair named default-ec2.pem, set 400 permissions, and organize it under aws/aws_keys for SSH access to EC2 instances.

Configure an AWS EC2 instance with Terraform by setting the AMI, key pair, instance type, security groups, and a subnet. Link instance to existing security groups and run terraform apply.

Learn to provision an EC2 http server with Terraform, inspect state and outputs, and use a remote-exec provisioner to install httpd and serve a custom index.html, highlighting immutability and re-provisioning.

Demonstrate deploying an http server on an ec2 instance with terraform, including destroying and applying configurations, managing dependencies, and verifying access via the server's public dns.

Explore immutable servers in infrastructure as code by provisioning new servers with updated configurations instead of in-place tweaks, then decommission old servers for a consistent, up-to-date system.

Learn to remove hard coding by adopting the AWS default VPC in Terraform, using data providers and dynamic values to replace static VPC IDs and AMI references.

Fetch dynamic subnet IDs with a Terraform data provider for AWS subnets in a VPC, convert sets to lists, and apply changes without hardcoding.

Make the AMI dynamic by using a data provider to fetch the latest Amazon Linux 2 AMI, then apply changes with Terraform to avoid hardcoding.

Visualize Terraform resource graph using dot format to see dependencies from default VPC to EC2; refactor into variables and data providers, then destroy to prepare for a load balancer.

Create six AWS EC2 instances across subnets with Terraform for_each, expose their public DNS via outputs, and configure a classic load balancer.

Create a security group and a classic load balancer in Terraform, configure HTTP on port 80 across subnets, distribute traffic to EC2 HTTP servers, and output the ELB DNS.

Automate infrastructure with Terraform to deploy AWS EC2 with a load balancer, observe DNS name switching as traffic balances across instances, then destroy resources to reduce costs.

Configure Terraform remote state with an S3 backend to share state across teams, moving from local tfstate to a centralized backend bucket for all Terraform projects.

Create a remote Terraform backend using an encrypted S3 bucket with versioning and prevent destroy, and enable DynamoDB locking to protect and isolate state across projects.

Configure Terraform to use an AWS S3 remote backend with a DynamoDB lock, moving the users project state from local to S3 and updating the backend key structure.

Discover how Terraform workspaces isolate state to create multiple environments, switch between prod-ENV and default, and embed workspace names into resource naming for environment-specific deployments.

Discover how to create multiple environments with Terraform modules, using dev and qa setups and per-environment backend state, while leveraging variables, locals, and module sources.

Discover how the in 28 minutes story turns change into an opportunity and champions learning something new every day, driven by curiosity across roles in DevOps.

Implement continuous integration, delivery, and deployment pipelines to get quick feedback from unit tests, integration tests, code quality checks, and packaging.

Explore Azure DevOps as a continuous integration, delivery, and deployment tool, build pipelines, run unit and integration tests, and manage approvals.

Master Azure DevOps pipelines for continuous integration and deployment, with multi-stage pipelines. Create an organization, set up a GitHub repository, and link it to your first pipeline.

Set up a GitHub repository, generate credentials, and push code to Azure DevOps pipelines by initializing a local folder and linking to the remote origin, enabling CI/CD for Kubernetes.

Connect an Azure DevOps pipeline to a GitHub repository, select a starter YAML, rename the pipeline file, commit to master, and run and review the job logs.

Learn how to run Azure DevOps pipelines, trigger builds manually or by git commits, and configure a master-triggered YAML pipeline that uses hosted agents and basic tasks.

Learn how Azure Pipelines organizes steps into jobs and tasks within stages, assigns each job to separate hosted agents, and executes jobs in parallel or in sequence.

Discover how to use depends on to sequence and parallelize pipeline jobs, achieve fan-in and fan-out, and manage execution with available agents in Azure DevOps.

Discover how to organize Azure DevOps pipelines into stages and jobs, create multiple pipelines, and use depends on to enforce sequential stage execution from build through production.

Explore managing Azure DevOps pipelines with stages and dependencies, disable unintended runs, and use variables at the pipeline, stage, and job levels to make deployments across Dev and QA efficient.

Explore how Azure DevOps predefined pipeline variables reveal build IDs, source branches, and working directories, then use them to manage artifact staging, publishing, and deployments across environments.

Learn to add and align Azure DevOps tasks for copying YAML and TF files from the default working directory to the artifact staging directory and publish artifacts for downstream stages.

Configure Azure pipelines to run the same build across multiple agents using a strategy matrix for Ubuntu latest and Mac OS-latest, creating parallel jobs and validating results.

Learn how Azure DevOps deployment jobs work, including stages, environments, and approvals. Build, dev deploy, and QA deploy pipelines demonstrate run-once deployments with environment approvals.

Learn how to set up an Azure DevOps pipeline that builds a Docker image from a Docker file and pushes it to Docker Hub, with a Docker Hub service connection.

Build and push a docker image in Azure DevOps using a multi-stage docker build, mvn clean install, and Docker Hub tagging with build labels.

Renaming and configuring Azure DevOps pipelines, enabling release pipelines, and using artifacts to deploy from dev to QA with approvals and variable scopes.

Provision Azure Kubernetes clusters with Terraform using Azure DevOps, and create two pipelines to provision the cluster and deploy Docker containers to microservices.

Review terraform configuration to create an Azure Kubernetes Service cluster with a resource group and backend state in Azure storage, and outline CI/CD pipelines to build and deploy containers.

Log in with Azure CLI, create a service account with contributor access to obtain the client ID and client secret, securely store credentials, and generate an RSA SSH key pair.

Learn to create an Azure DevOps pipeline for an Azure Kubernetes cluster using Terraform, including a resource manager service connection and a remote backend with a storage account.

Execute Terraform apply to create an Azure Kubernetes cluster, after initializing the backend with a storage account and container and logging in via a service principal.

Install Azure CLI to interact with your Azure account from the command line; follow OS-specific installers (Windows, macOS with Homebrew, Linux via apt/yum/zypper or a script) and verify az --version.

Connect to an Azure Kubernetes service cluster using the Azure CLI, fetch credentials, and verify the cluster with kubectl while reviewing node pools and the IaC-based ci/cd pipeline.

Create a CI/CD pipeline in Azure DevOps that builds a Docker image, publishes Kubernetes manifests, and deploys a currency exchange microservice to Azure AKS.

Structure pipelines by separating infrastructure and deployment: provision a Kubernetes cluster with Terraform in one pipeline and deploy Docker images in another, using one GitHub repository per microservice.

Edit the code to enable v2, build and push the new docker image. Deploy with kubectl, retrieve the external IP on port 8000, and verify a healthy response.

Build and push a docker image for a java app, then deploy v2 via kubectl by updating the deployment with the new tag, enabling a ci/cd pipeline.

Execute Terraform destroy in the zero five IaaC pipeline to delete the Azure Kubernetes cluster, highlighting infrastructure as code destruction and cost avoidance in a DevOps workflow.

Practice Terraform destroy with auto approve to delete the Kubernetes cluster and its resource group in Azure, highlighting the cost rationale and disabling destroy in the iaac pipeline.

Provision an AWS EKS cluster with Terraform and deploy docker containers to Kubernetes, using two Azure DevOps pipelines for provisioning and CI/CD.

Provision an aws eks cluster with terraform main.tf and the aws eks module, configure nodes and remote s3 backend, then deploy the currency exchange app using docker and kubernetes.

Create an s3 bucket for terraform backend state with versioning and encryption, configure default vpc subnets, and prepare changes for azure devops.

Enable AWS tools in Azure DevOps, create an AWS service connection for Terraform, and configure a Kubernetes cluster pipeline using Terraform init and apply with an S3 backend.

Initialize Terraform with a backend config, configure AWS credentials and region, then apply to provision an AWS EKS cluster in an Azure DevOps pipeline.

Retry the Terraform apply to create the Kubernetes cluster binding, inspect the TF state in S3, and confirm the EKS cluster and node group setup for the next CI deployment.

Install AWS cli version 1 using bundled installer for macOS or Linux, or Windows msi; verify with aws --version; AWS CLI lets you interact with AWS account and see resources.

Create an AWS Kubernetes service connection in Azure DevOps, configure the AWS CLI and kubeconfig, and enable a ci/cd pipeline that deploys GitHub changes to the EKS cluster.

Learn to build and push a Docker image, publish Kubernetes manifests as artifacts, and deploy to an AWS EKS cluster via kubectl apply using a two-stage Azure DevOps pipeline.

Configure a v3 Docker image build and push in Azure DevOps, update Kubernetes deployment.yaml, and apply the deployment while verifying the currency exchange service is running.

Follow the ci/cd flow as Azure DevOps builds and pushes Docker image 44 to Docker Hub, then kubectl apply updates deployment.yaml to Kubernetes, yielding V3 live at the load balancer.

Enable the IAC pipeline and configure a Terraform destroy task to delete the AWS EKS cluster in Azure DevOps, safely cleaning up resources.

Perform a Terraform destroy in the Azure DevOps pipeline to delete the AWS EKS cluster and all associated resources in the us-east-1 region, demonstrating end-to-end IaC and CI/CD workflow.

Create a sample Azure DevOps project using the Azure DevOps Demo Generator, sign in, select your organization, choose a Scrum template, and observe automatic setup of teams and project resources.

Discover an overview of Azure DevOps with boards, repos, pipelines and wiki, manage epics, features, backlog items and bugs, and explore dashboards and artifacts for agile projects.

Explore Azure DevOps boards in depth, comparing Agile, Scrum, and CMMI processes, and learn how epics, features, user stories, and tasks flow from portfolio backlog to sprint backlog.

Explore Azure DevOps boards and backlogs, viewing work items by state and customizing statuses. Then prioritize items, add details, acceptance criteria, and link relationships across epics, features, and backlog items.

Learn how to manage Azure DevOps sprints, create and configure sprints, assign work items, track progress with tasks from backlog to done, and balance capacity and days off.

Learn how to create, save, and run Azure DevOps queries to track work item status across epics, features, and code review requests, and display results on dashboards.

Explore Azure DevOps repos, a built-in git-like repository stored with your project, enabling in-browser editing, commits, branches, and pull requests for code reviews.

Explore Azure DevOps pipelines, enable continuous integration, batch changes, choose branches, and compare classic editor and YAML workflows while building and publishing artifacts and Docker images.

Explore Azure DevOps board, repos, pipelines, test plans, and artifacts for jar files and npm packages. See how it deploys code to any cloud provider in a versatile, 10,000-foot overview.