
Provisions an AWS-based cluster and manages infrastructure with Terraform, while setting up a local environment using Docker Desktop and a code editor like visual code to run and test containers.
Join a hands-on, integrated approach to mastering docker, terraform, and helm for eks, with clear explanations and focus on avoiding copy-paste, practical command-line exercises that work natively or in containers.
Install terraform in a container using the official hashi image, spin up the container, check the available version, and confirm the installation.
Provisions an EKS cluster by leveraging a Terraform module to create VPCs, subnets, DNS and related resources, then initialize, validate, plan, and apply changes to deploy master nodes.
Provision worker nodes by applying the launch templates and scaling group, then verify the cluster and node status in the console and dashboard to confirm it’s up.
Install kubectl and aws-iam-authenticator, configure the cluster using terraform outputs, verify access by running the authenticator, and validate by listing namespaces and nodes.
Learn how to deploy the aws-auth config map to authorize worker nodes to join an EKS cluster, mapping identities with mapRoles and mapUsers, and verify node join.
Explore how EKS authenticates users by reading cluster configuration, obtaining user tokens via a WS authenticator, and validating tokens against IAM identities mapped in the IWC config map.
Create a read-only AWS user with programmatic access, configure EKS credentials, and test authentication and authorization, revealing access denial when unauthorized.
Bind the audit team group to a predefined EKS cluster view, create and apply an access file, and update Terraform to grant the user cluster API access.
Learn why Terraform enables infrastructure as code with versioning, testing, and reusability, and how to set up CI/CD for deploying a cluster in production.
Master infrastructure as code with Terraform, defining the desired state and applying changes to reach it. Use modules to reuse resources across providers and compare with CloudFormation.
Discover Terraform's HCL by defining a local provider resource block, learning resource type and name labels, and applying required and optional arguments like file name and content.
Learn how to initialize a Terraform configuration with Terraform init, install the local provider, and verify providers in your project, using documentation for subcommands.
Execute terraform apply to display the plan, approve changes with yes, complete the apply, verify the created resource file and its contents, and run terraform show to inspect the state.
Deploy the same application with helm charts to demonstrate why helm is essential for production Kubernetes, enabling value externalization, templating, and chart packaging.
Install the Helm command line interface locally and verify its setup against your cluster. Configure volumes and credentials to enable Helm authentication and chart deployment.
Create and install a HelloWorld Helm chart, configure the image repository in values, and deploy the application in a namespace, then forward port to access the web app.
docker-compose run --rm helm install metrics-server stable/metrics-server --version 2.8.2 --namespace kube-system -f charts/metrics-server/values.yaml
docker-compose run --rm helm install cluster-autoscaler stable/cluster-autoscaler --namespace kube-system -f charts/metrics-server/cluster-autoscaler/values.yaml
docker-compose run --rm helm install ingress stable/nginx-ingress --namespace kube-system -f charts/nginx-ingress/values.yaml
docker-compose run --rm helm upgrade ingress stable/nginx-ingress --namespace kube-system -f charts/nginx-ingress/values.yaml
docker-compose run --rm helm install prom stable/prometheus-operator --namespace monitoring -f charts/prometheus/values.yaml
This is an overview about CRDs (custom resource definitions) installed by the Helm Chart: Prometheus-Operator.
By mastering this lecture, you will be able to understand the integration between many applications & Prometheus.
Learn how to integrate the engine X ingress controller with Prometheus by enabling the matrix block and service monitor, expose the metrics port, and upgrade Prometheus to view ingress dashboard.
The objective of this lecture is to stop adding charts to avoid the Mess of installing helm charts with these adhoc commands "helm install", "helm upgrade".
Adhoc command violates the production grade of operating the infrastructure.
Compare helmfile and ansible for organizing helm charts, outlining playbooks and hidden files, noting templating and symbols, with beta status.
Install helmfile by defining a new container in a local compose file, replacing it with a helmfile-enabled image, and authenticate with the cluster to verify deployment.
Migrate to helmfile to manage releases like matrix server, define repositories and hidden defaults, and upgrade the chart while using helm diff to verify changes.
pin chart versions to ensure production reliability by avoiding upgrades to the latest charts; specify exact versions for each release, verify upgrades with a single command, and prevent surprises.
Learn how to externalize secrets in helmfile with helm 5 by moving passwords into environment variables and a secret file, avoiding plaintext in values and enabling secure container access.
Refactor docker-compose to support multi-environment setups by applying convention over configuration, using default for production and staging for the staging environment, and scripting auto-selection of the right compose files.
Refactor the hidden file to support multi-environment deployments with default and staging configurations, using environment-specific values and helmfile-driven installs like ingress and Prometheus.
https://aws.amazon.com/about-aws/whats-new/2020/03/amazon-eks-now-supports-kubernetes-version-1-15/
https://registry.terraform.io/modules/terraform-aws-modules/eks/aws/10.0.0
https://github.com/terraform-aws-modules/terraform-aws-eks/pull/776
Upgrade the EKS terraform module from 7.0.0 to 9.0.0, addressing provider changes, integrating the communities provider, and moving from static to dynamic configuration in staging.
Upgrade the control plane to k8s v1.15 and upgrade the community cluster from 1.14 to 1.15. Check the cluster status and plan worker node upgrade for next lecture.
Destroy the staging cluster to cut costs and save time, using Terraform destroy to decommission the environment, and then proceed with upgrading the production environment.
Identify removed API versions in deployed resources and migrate to apps/v1 for deployments, then upgrade charts with downtime-aware strategies.
Upgrade EKS control plane to Kubernetes 1.16 using Terraform to download and apply the new module. Verify status; the control plane reaches 1.16 while workers stay at 1.15.
Patch the VPC CNI plugin on an EKS cluster by checking the current version, noting add-ons such as Amazon VPC CNI, DNS and proxy, and upgrading with the provided command.
Upgrade CoreDNS by checking the current deployment version and applying a patch when needed. Verify the CoreDNS version (1.6.6) and replace outdated components in your cluster.
Perform a rolling update of EKS worker nodes to Kubernetes v1.16 by draining workloads and replacing old nodes with new ones. Let auto scaling replace them and monitor status.
<<<< DISCLAIMER: If you are not familiar with Docker, you may find this course hard. Please think twice before purchase >>>>
==============================================
A production experience with kubernetes on AWS has been summarized for you in few minutes !
We designed this course for anyone seeking to setup a Kubernetes Cluster on AWS for production workload , and reuse this setup with any other AWS account or any other Cloud Provider.
We believe that Production requires reliability , while reliability requires codification of all operations.
From this principle, we designed this course to explain how you operate a Kubernetes cluster on production namely with AWS EKS using the most relevant "As-Code" Techs:
- Terraform : Infra as Code
- Helm : Kubernetes Apps as Code
- Helmfile: Helm Releases as Code
- Docker-compose: Containers as Code for executing some CLIs.
- Jenkinsfile : Pipeline as Code
By the end of the course, :
You will be Able to Setup a Kubernetes Cluster on AWS quickly and effectively
You will be Comfortable to Reproduce your infrastructure with any other Cloud provider.
You will be able to make your kubernetes cluster ready for production workload by deploying core applications like: prometheus, grafana, metrics-server, cluster-autoscaler, Ingress and others.
you will be able to develop Helm Chart for your own applications and release your apps to Kubernetes Cluster via Helm
You will able to leverage Software-Development-Lifecycle to operate your cluster like a Software Developer.
You will be able to setup a CI/CD system like Jenkins , ready for production CI/CD pipelines workload, with integration with Github, Oauth and others.