• GNU Make >= 4.2.1
• terrafrom >= v1.6.6
• terragrunt >= v0.54.8
• jq >= 1.6
• aws IAM user + Access key (or IAM role ) with Admin privilege for VPC, EC2, IAM, EKS
• AWS CLI > 2.2.30
• aws profile

Or you can run via docker ( video instruction )

The repository is organized into the following sections:

• Makefile - File contains scenarios for launching hands-on labs and mock exams.
• tasks - Directory contains lab scenarios and mock exam scripts.
  • cka - Directory contains everything related to CKA.
    • labs - Directory contains hands-on labs for the CKA exam.
    • mock - Directory contains mock scripts for the CKA exam.
  • cks - Directory contains everything related to CKS.
    • labs - Directory contains hands-on labs for the CKS exam.
    • mock - Directory contains mock scripts for the CKS exam.
• terraform - Directory contains modules and Terraform environments.
  • environments - Directory contains terragrunt (terraform) environments.
  • modules - Directory contains terraform modules.

• the platform uses aws to create following resources : vpc, subnets, security groups, ec2 (spot ), s3
• after you launch the scenarios the platform will create all the necessary resources and give access to k8s clusters.
• to create clusters the platform uses kubeadm
• you can easily add your own scenario using the already existing terraform module k8s_self_managment
• k8s_self_managment module supports versions:

k8s version  : [ 1.21 , 1.34 ]   https://kubernetes.io/releases/
Rintime :
    docker                   [1.21 , 1.23]
    cri-o                    [1.21 , 1.29]
    containerd               [1.21 , 1.33]   # cks, cka  default 1.33
    containerd_gvizor        [1.21 , 1.33]
OS for nodes  :
   ubuntu  :  20.04 LTS  ,  22.04 LTS   # cks default  22.04 LTS
CNI :  calico ,culium

• make cmdb_get_env_all - get a list of all resources in CMDB
• USER_ID='myuser' ENV_ID='01' make cmdb_get_user_env_data - show all created resources of user myuser in environment 01
• USER_ID='myuser' ENV_ID='01' make cmdb_get_user_env_lock - show all lock resources of user myuser in environment 01
• USER_ID='myuser' ENV_ID='01' make cmdb_get_user_env_lock - show all lock resources of user myuser in environment 01
• USER_ID='myuser' make cmdb_get_user_env_lock - show all lock resources of user myuser in all environment
• USER_ID='myuser' make cmdb_get_user_env_data - show all data resources of user myuser in all environment
• CMDB_ITEM='CMDB_data_myuser_02_k8s_cluster1' make cmdb_get_item - getting detailed information about CMDB_data_myuser_02_k8s_cluster1 resource.

cka task

• TASK=01 make run_cka_task - create cka hands-on labs number 01
• TASK=01 make delete_cka_task - delete cka hands-on labs
• TASK=01 make run_cka_task_clean - run cka_task with clean terragrunt cache for cka_task
• make output_cka_task - show outputs from cka_task

cka mock

• TASK=01 make run_cka_mock - create mock CKA exam number 01
• make delete_cka_mock - delete mock CKA exam
• TASK=01 make run_cka_mock_clean - create mock CKA exam number 01 with clean terragrunt cache
• make output_cka_mock - show outputs from cka_mock

ckad mock

• TASK=01 make run_ckad_mock - create mock CKAD exam number 01
• make delete_ckad_mock - delete mock CKAD exam
• TASK=01 make run_ckad_mock_clean - create mock CKAD exam number 01 with clean terragrunt cache
• make output_ckad_mock - show outputs from ckad_mock

cks task

• TASK=10 make run_cks_task - create cks hands-on labs number 10
• TASK=10 make delete_cks_task - delete cks hands-on labs
• TASK=10 make run_cks_task_clean - run cks_task with clean terragrunt cache for cks_task
• make output_cks_task - show outputs from cks_task

cks mock

• TASK=01 make run_cks_mock - create mock CKS exam number 01
• make delete_cks_mock - delete mock CKS exam
• TASK=01 make run_cks_mock_clean - create mock CKS exam number 01 with clean terragrunt cache
• make output_cks_mock - show outputs from cks_mock

ica task

• TASK=01 make run_ica_task - create ica hands-on labs number 01
• TASK=01 make delete_ica_task - delete ica hands-on labs
• TASK=01 make run_ica_task_clean - run ica_task with clean terragrunt cache for ica_task
• make output_cks_task - show outputs from ica_task

ica mock

• TASK=01 make run_ica_mock - create mock ica exam number 01
• make delete_ica_mock - delete mock ica exam
• TASK=01 make run_ica_mock_clean - create mock ica exam number 01 with clean terragrunt cache
• make output_ica_mock - show outputs from cks_mock

lfcs mock

• TASK=01 make run_lfcs_mock - create mock LFCS exam number 01
• make delete_lfcs_mock - delete mock LFCS exam
• TASK=01 make delete_lfcs_mock_clean - delete mock LFCS exam number 01 with cleaning terragrunt cache
• make output_lfcs_mock - show outputs from lfcs_mock

KCNA

• check examle questions in kcna directory

• check examle questions in kcsa directory

• TASK=01 make run_hr_mock - create mock hr exam number 01
• make delete_hr_mock - delete mock hr exam
• TASK=01 make run_hr_mock_clean - create mock CKS exam number 01 with clean terragrunt cache
• make output_hr_mock - show outputs from hr_mock

• TASK={lab_number} make run_eks_task create hands-on lab
• make delete_eks_task delete eks lab cluster

• make lint run linter on the project

example questions for AWS Certified AI Practitioner exam

• check examle questions in AWS Certified AI Practitioner directory

• choose a hands-on lab number
• create cka lab cluster TASK={lab_number} make run_cka_task
• find {master_external_ip} in terraform output
• log in to master node via ssh ssh ubuntu@{master_external_ip} -i {key}
• check init logs tail -f /var/log/cloud-init-output.log
• read lab descriptions in {lab_number}/README.MD
• check solution in {lab_number}/SOLUTION.MD
• delete cka lab cluster make delete_cka_task
• clean cka lab cluster .terraform folder make clean_cka_task

Video instruction for launching CKA mock exam

• choose a mock exam number
• change instance type from spot to ondemand in {mock_number}/env.hcl if you need
• create mock CKA exam TASK={mock_number} make run_cka_mock
• find worker_pc_ip in terraform output
• connect to worker_pc_ip with your ssh key and user ubuntu
• open questions list {mock_number}/README.MD and do tasks
• use ssh {kubernetes_nodename} from work pc to connect to node
• run time_left on work pc to check time
• run check_result on work pc to check result
• delete mock CKA exam make delete_cka_mock
• find exam solutions in {mock_number}/worker/files/solutions) and * Video for mock 01 .
• find exam tests in {mock_number}/worker/files/tests.bats)

• choose CKS lab number
• change ami_id in {lab_number}/scripts/terragrunt.hcl if you changed region
• create cka lab cluster TASK={lab_number} make run_cks_task
• find {master_external_ip} in terraform output
• log in to master node via ssh ssh ubuntu@{master_external_ip} -i {key}
• check init logs tail -f /var/log/cloud-init-output.log
• read lab descriptions in {lab_number}/README.MD
• check solution in {lab_number}/SOLUTION.MD
• delete cks lab cluster make delete_cks_task
• clean cks lab cluster .terraform folder make clean_cks_task

Video instruction for launching CKS mock exam

mock CKS exam

• choose a mock exam number
• change ubuntu_version in {mock_number}/env.hcl if you need
• change instance type from spot to ondemand in {mock_number}/env.hcl if you need
• create mock CKS exam TASK={mock_number} make run_cks_mock or TASK={mock_number} make run_cks_mock_clean if you'd like to run with clean terragrunt cache
• find worker_pc_ip in terraform output
• connect to worker_pc_ip with your ssh key and user ubuntu
• open questions list {mock_number}/README.MD and do tasks
• use ssh {kubernetes_nodename} from work pc to connect to node
• run time_left on work pc to check time
• run check_result on work pc to check result
• delete mock CKS exam make delete_cks_mock
• find exam solutions in {mock_number}/worker/files/solutions mock 1 solutions and video
• find exam tests in {mock_number}/worker/files/tests.bats

mock ICA exam

• choose a mock exam number
• change ubuntu_version in {mock_number}/env.hcl if you need
• change instance type from spot to ondemand in {mock_number}/env.hcl if you need
• create mock CKS exam TASK={mock_number} make run_ica_mock or TASK={mock_number} make run_ica_mock_clean if you'd like to run with clean terragrunt cache
• find worker_pc_ip in terraform output
• connect to worker_pc_ip with your ssh key and user ubuntu
• open questions list {mock_number}/README.MD and do tasks
• use ssh {kubernetes_nodename} from work pc to connect to node
• run time_left on work pc to check time
• run check_result on work pc to check result
• delete mock CKS exam make delete_ica_mock
• find exam solutions in {mock_number}/worker/files/solutions mock 1 solutions and video
• find exam tests in {mock_number}/worker/files/tests/

Video instruction for launching CKAD mock exam

mock CKAD exam

• choose a mock exam number
• change ubuntu_version in {mock_number}/env.hcl if you need
• change instance type from spot to ondemand in {mock_number}/env.hcl if you need
• create mock CKAD exam TASK={mock_number} make run_ckad_mock or TASK={mock_number} make run_ckad_mock_clean if you'd like to run with clean terragrunt cache
• find worker_pc_ip in terraform output
• connect to worker_pc_ip with your ssh key and user ubuntu
• open questions list {mock_number}/README.MD and do tasks
• use ssh {kubernetes_nodename} from work pc to connect to node
• run time_left on work pc to check time
• run check_result on work pc to check result
• delete mock CKAD exam make delete_ckad_mock
• find exam solutions in {mock_number}/worker/files/solutions mock 1 solutions and video
• find exam tests in {mock_number}/worker/files/tests.bats

example questions for KCNA exam

• check examle questions in kcna directory

example questions for KCSA exam

• check examle questions in kcsa directory

Video instruction for launching HR mock exam

mock HR exam

• choose a mock exam number
• change ubuntu_version in {mock_number}/env.hcl if you need
• change instance type from spot to ondemand in {mock_number}/env.hcl if you need
• create mock CKS exam TASK={mock_number} make run_hr_mock or TASK={mock_number} make run_hr_mock_clean if you'd like to run with clean terragrunt cache
• find worker_pc_ip in terraform output
• connect to worker_pc_ip with your ssh key and user ubuntu
• open questions list {mock_number}/README.MD and do tasks
• use ssh {kubernetes_nodename} from work pc to connect to node
• run time_left on work pc to check time
• run check_result on work pc to check result
• delete mock CKA exam make delete_hr_mock
• find exam solutions in {mock_number}/worker/files/solutions mock 1 solutions and video
• find exam tests in {mock_number}/worker/files/tests.bats

• choose labs number
• create hands-on lab TASK={lab_number} make run_eks_task
• find worker_pc_ip in terraform output
• log in to worker_pc node via ssh ssh ubuntu@{worker_pc_ip} -i {key}
• read lab descriptions in {lab_number}/README.MD
• check solution in {lab_number}/SOLUTION.MD
• delete eks lab cluster make delete_eks_task