Skip to content

Latest commit

 

History

History
299 lines (230 loc) · 16 KB

README.MD

File metadata and controls

299 lines (230 loc) · 16 KB
Raw

Welcome to the SRE Learning Platform!

The SRE Learning Platform is an open-source hub designed to help IT engineers effectively prepare for the CKA (Certified Kubernetes Administrator), CKS (Certified Kubernetes Security Specialist), and CKAD (Certified Kubernetes Application Developer) exams. Additionally, this platform offers invaluable hands-on experience with AWS EKS (Elastic Kubernetes Service), equipping users with practical insights for real-world applications. Whether you're aiming to validate your skills, boost your career prospects in Kubernetes administration, security, application development, or delve into AWS EKS, this platform provides hands-on labs, practice tests, and expert guidance to ensure certification success.

Master Kubernetes concepts, gain practical experience, and excel in the CKA, CKS, and CKAD exams with the SRE Learning Platform.

Repository Structure

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.

Requirements

Or you can run via docker ( video instruction )

About CKA, CKS, CKAD scenarios

  • 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.29 ]   https://kubernetes.io/releases/
Rintime :
    docker                   [1.21 , 1.23]
    cri-o                    [1.21 , 1.29]
    containerd               [1.21 , 1.29]   # cks, cka  default 1.28
    containerd_gvizor        [1.21 , 1.29]
OS for nodes  :
   ubuntu  :  20.04 LTS  ,  22.04 LTS   # cks default  20.04 LTS
CNI :  calico

Configuration

Command

Every command should be run from the project's root directory.

CMDB
  • 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

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

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

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
HR
  • 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
EKS
  • TASK={lab_number} make run_eks_task create hands-on lab
  • make delete_eks_task delete eks lab cluster
DEV
  • make lint run linter on the project

Usage scenarios

CKA hands-on lab
  • 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
mock CKA exam

Video instruction for launching CKA mock exam

  • choose a mock exam number
  • change instance type from spot to on-demand 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)
CKS hands-on lab
  • 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
mock CKS exam

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 on-demand 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 CKAD exam

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 on-demand 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
mock HR exam

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 on-demand 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
EKS hands-on lab
  • 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

Simultaneous work with independent environments

Useful links

Tips And Tricks

CHANGELOG

CODE OF CONDUCT

Contribution

If you want to be part of the project development team, get in touch with us. We are always happy to welcome new members to our development team

If you want to say thank you or/and support the active development of SRE Learning Platform project :

  • Star the SRE Learning Platform project on Github
  • Feel free to write articles about the project on dev.to, medium, hackernoon or on your personal blog and share your experiences

License and Usage Agreement

Contacts

If you encounter any issues or have questions about the project, you can reach out to:

email Telegram LinkedI