From 882945e211227441f715279186174b8d639deb89 Mon Sep 17 00:00:00 2001 From: github-actions Date: Thu, 5 Aug 2021 15:29:50 +0000 Subject: [PATCH] Deployed 95b5e64 with MkDocs version: 1.1.2 --- 404.html | 100 + CODE_OF_CONDUCT/index.html | 100 + CONTRIBUTING/index.html | 102 +- index.html | 100 + level101/big_data/evolution/index.html | 100 + level101/big_data/intro/index.html | 100 + level101/big_data/tasks/index.html | 100 + .../further_reading/index.html | 100 + level101/databases_nosql/intro/index.html | 100 + .../databases_nosql/key_concepts/index.html | 100 + .../databases_sql/backup_recovery/index.html | 100 + level101/databases_sql/concepts/index.html | 100 + level101/databases_sql/conclusion/index.html | 100 + level101/databases_sql/innodb/index.html | 100 + level101/databases_sql/intro/index.html | 100 + level101/databases_sql/lab/index.html | 100 + level101/databases_sql/mysql/index.html | 100 + level101/databases_sql/operations/index.html | 100 + .../query_performance/index.html | 100 + level101/databases_sql/replication/index.html | 100 + .../databases_sql/select_query/index.html | 100 + level101/git/branches/index.html | 100 + level101/git/conclusion/index.html | 100 + level101/git/git-basics/index.html | 100 + level101/git/github-hooks/index.html | 100 + .../command_line_basics/index.html | 100 + level101/linux_basics/conclusion/index.html | 100 + level101/linux_basics/intro/index.html | 100 + .../linux_server_administration/index.html | 100 + .../linux_networking/conclusion/index.html | 100 + level101/linux_networking/dns/index.html | 100 + level101/linux_networking/http/index.html | 100 + level101/linux_networking/intro/index.html | 100 + level101/linux_networking/ipr/index.html | 100 + level101/linux_networking/tcp/index.html | 100 + level101/linux_networking/udp/index.html | 100 + .../metrics_and_monitoring/alerts/index.html | 100 + .../best_practices/index.html | 100 + .../command-line_tools/index.html | 100 + .../conclusion/index.html | 100 + .../introduction/index.html | 100 + .../observability/index.html | 100 + .../third-party_monitoring/index.html | 100 + level101/python_web/intro/index.html | 100 + .../python_web/python-concepts/index.html | 100 + .../python_web/python-web-flask/index.html | 100 + level101/python_web/sre-conclusion/index.html | 100 + .../python_web/url-shorten-app/index.html | 100 + level101/security/conclusion/index.html | 100 + level101/security/fundamentals/index.html | 100 + level101/security/intro/index.html | 100 + level101/security/network_security/index.html | 100 + .../threats_attacks_defences/index.html | 100 + .../security/writing_secure_code/index.html | 100 + .../systems_design/availability/index.html | 100 + level101/systems_design/conclusion/index.html | 100 + .../systems_design/fault-tolerance/index.html | 100 + level101/systems_design/intro/index.html | 100 + .../systems_design/scalability/index.html | 100 + .../conclusion/index.html | 104 +- .../containerization_with_docker/index.html | 100 + .../intro/index.html | 100 + .../intro_to_containers/index.html | 100 + .../orchestration_with_kubernetes/index.html | 100 + .../conclusion/index.html | 1698 +++++++++++++++ .../images/FlaskCode.png | Bin 0 -> 208487 bytes .../images/FlaskStart.png | Bin 0 -> 62805 bytes .../images/MemUsage01.png | Bin 0 -> 49329 bytes .../images/MemUsage02.png | Bin 0 -> 208660 bytes .../images/MemUsage03.png | Bin 0 -> 156278 bytes .../images/MemUsageChart.png | Bin 0 -> 23960 bytes .../images/Tracemalloc01.png | Bin 0 -> 61053 bytes .../images/Tracemalloc02.png | Bin 0 -> 58211 bytes .../images/Tracemalloc03.png | Bin 0 -> 46557 bytes .../images/TroubleshootingFlow.jpg | Bin 0 -> 40755 bytes .../important-tools/index.html | 1733 ++++++++++++++++ .../introduction/index.html | 1841 +++++++++++++++++ .../performance-improvements/index.html | 1776 ++++++++++++++++ .../troubleshooting-example/index.html | 1719 +++++++++++++++ .../troubleshooting/index.html | 1759 ++++++++++++++++ search/search_index.json | 2 +- sitemap.xml | 150 +- sitemap.xml.gz | Bin 225 -> 230 bytes sre_community/index.html | 100 + 84 files changed, 17117 insertions(+), 67 deletions(-) create mode 100644 level102/system_troubleshooting_and_performance/conclusion/index.html create mode 100644 level102/system_troubleshooting_and_performance/images/FlaskCode.png create mode 100644 level102/system_troubleshooting_and_performance/images/FlaskStart.png create mode 100644 level102/system_troubleshooting_and_performance/images/MemUsage01.png create mode 100644 level102/system_troubleshooting_and_performance/images/MemUsage02.png create mode 100644 level102/system_troubleshooting_and_performance/images/MemUsage03.png create mode 100644 level102/system_troubleshooting_and_performance/images/MemUsageChart.png create mode 100644 level102/system_troubleshooting_and_performance/images/Tracemalloc01.png create mode 100644 level102/system_troubleshooting_and_performance/images/Tracemalloc02.png create mode 100644 level102/system_troubleshooting_and_performance/images/Tracemalloc03.png create mode 100644 level102/system_troubleshooting_and_performance/images/TroubleshootingFlow.jpg create mode 100644 level102/system_troubleshooting_and_performance/important-tools/index.html create mode 100644 level102/system_troubleshooting_and_performance/introduction/index.html create mode 100644 level102/system_troubleshooting_and_performance/performance-improvements/index.html create mode 100644 level102/system_troubleshooting_and_performance/troubleshooting-example/index.html create mode 100644 level102/system_troubleshooting_and_performance/troubleshooting/index.html diff --git a/404.html b/404.html index 2f3c0c1..f873bf7 100644 --- a/404.html +++ b/404.html @@ -1349,6 +1349,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/CODE_OF_CONDUCT/index.html b/CODE_OF_CONDUCT/index.html index c0e6f6c..cdfbe07 100644 --- a/CODE_OF_CONDUCT/index.html +++ b/CODE_OF_CONDUCT/index.html @@ -1354,6 +1354,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/CONTRIBUTING/index.html b/CONTRIBUTING/index.html index 5726224..23a5d7e 100644 --- a/CONTRIBUTING/index.html +++ b/CONTRIBUTING/index.html @@ -1354,6 +1354,106 @@ + + + + + +
  • + + + + + + +
    • + + + @@ -1552,7 +1652,7 @@ mkdocs serve
    diff --git a/level101/big_data/evolution/index.html b/level101/big_data/evolution/index.html index 52184e3..d1b63c3 100644 --- a/level101/big_data/evolution/index.html +++ b/level101/big_data/evolution/index.html @@ -1369,6 +1369,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/big_data/intro/index.html b/level101/big_data/intro/index.html index f3dfcb8..c8260dd 100644 --- a/level101/big_data/intro/index.html +++ b/level101/big_data/intro/index.html @@ -1419,6 +1419,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/big_data/tasks/index.html b/level101/big_data/tasks/index.html index bac0d15..1e3189e 100644 --- a/level101/big_data/tasks/index.html +++ b/level101/big_data/tasks/index.html @@ -1405,6 +1405,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_nosql/further_reading/index.html b/level101/databases_nosql/further_reading/index.html index abc096e..6a673de 100644 --- a/level101/databases_nosql/further_reading/index.html +++ b/level101/databases_nosql/further_reading/index.html @@ -1369,6 +1369,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_nosql/intro/index.html b/level101/databases_nosql/intro/index.html index 1d6f768..c33a449 100644 --- a/level101/databases_nosql/intro/index.html +++ b/level101/databases_nosql/intro/index.html @@ -1460,6 +1460,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_nosql/key_concepts/index.html b/level101/databases_nosql/key_concepts/index.html index 339e791..9763ea9 100644 --- a/level101/databases_nosql/key_concepts/index.html +++ b/level101/databases_nosql/key_concepts/index.html @@ -1439,6 +1439,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_sql/backup_recovery/index.html b/level101/databases_sql/backup_recovery/index.html index 92232ba..b2d928e 100644 --- a/level101/databases_sql/backup_recovery/index.html +++ b/level101/databases_sql/backup_recovery/index.html @@ -1421,6 +1421,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_sql/concepts/index.html b/level101/databases_sql/concepts/index.html index 3e57c7b..1b372fd 100644 --- a/level101/databases_sql/concepts/index.html +++ b/level101/databases_sql/concepts/index.html @@ -1394,6 +1394,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_sql/conclusion/index.html b/level101/databases_sql/conclusion/index.html index 075dbf4..48a4115 100644 --- a/level101/databases_sql/conclusion/index.html +++ b/level101/databases_sql/conclusion/index.html @@ -1398,6 +1398,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_sql/innodb/index.html b/level101/databases_sql/innodb/index.html index b1a4e3d..e0e59c6 100644 --- a/level101/databases_sql/innodb/index.html +++ b/level101/databases_sql/innodb/index.html @@ -1408,6 +1408,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_sql/intro/index.html b/level101/databases_sql/intro/index.html index 4b5ee22..1d13e10 100644 --- a/level101/databases_sql/intro/index.html +++ b/level101/databases_sql/intro/index.html @@ -1433,6 +1433,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_sql/lab/index.html b/level101/databases_sql/lab/index.html index b33f4a6..1f66287 100644 --- a/level101/databases_sql/lab/index.html +++ b/level101/databases_sql/lab/index.html @@ -1362,6 +1362,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_sql/mysql/index.html b/level101/databases_sql/mysql/index.html index 84b32d0..93da52d 100644 --- a/level101/databases_sql/mysql/index.html +++ b/level101/databases_sql/mysql/index.html @@ -1394,6 +1394,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_sql/operations/index.html b/level101/databases_sql/operations/index.html index 0d568e7..d57f2e2 100644 --- a/level101/databases_sql/operations/index.html +++ b/level101/databases_sql/operations/index.html @@ -1349,6 +1349,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_sql/query_performance/index.html b/level101/databases_sql/query_performance/index.html index c731fec..7dff9bb 100644 --- a/level101/databases_sql/query_performance/index.html +++ b/level101/databases_sql/query_performance/index.html @@ -1423,6 +1423,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_sql/replication/index.html b/level101/databases_sql/replication/index.html index 04e0fd2..cbc1dc7 100644 --- a/level101/databases_sql/replication/index.html +++ b/level101/databases_sql/replication/index.html @@ -1414,6 +1414,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/databases_sql/select_query/index.html b/level101/databases_sql/select_query/index.html index 1a255e1..48b5730 100644 --- a/level101/databases_sql/select_query/index.html +++ b/level101/databases_sql/select_query/index.html @@ -1416,6 +1416,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/git/branches/index.html b/level101/git/branches/index.html index a9a6e88..ea43a4e 100644 --- a/level101/git/branches/index.html +++ b/level101/git/branches/index.html @@ -1398,6 +1398,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/git/conclusion/index.html b/level101/git/conclusion/index.html index 10b843a..19273fc 100644 --- a/level101/git/conclusion/index.html +++ b/level101/git/conclusion/index.html @@ -1394,6 +1394,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/git/git-basics/index.html b/level101/git/git-basics/index.html index 98a2183..69f0fa4 100644 --- a/level101/git/git-basics/index.html +++ b/level101/git/git-basics/index.html @@ -1495,6 +1495,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/git/github-hooks/index.html b/level101/git/github-hooks/index.html index b6911df..a52cc28 100644 --- a/level101/git/github-hooks/index.html +++ b/level101/git/github-hooks/index.html @@ -1398,6 +1398,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/linux_basics/command_line_basics/index.html b/level101/linux_basics/command_line_basics/index.html index fd4513f..6731a6e 100644 --- a/level101/linux_basics/command_line_basics/index.html +++ b/level101/linux_basics/command_line_basics/index.html @@ -1583,6 +1583,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/linux_basics/conclusion/index.html b/level101/linux_basics/conclusion/index.html index 72bf04b..e505477 100644 --- a/level101/linux_basics/conclusion/index.html +++ b/level101/linux_basics/conclusion/index.html @@ -1405,6 +1405,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/linux_basics/intro/index.html b/level101/linux_basics/intro/index.html index 53da01c..077cb1d 100644 --- a/level101/linux_basics/intro/index.html +++ b/level101/linux_basics/intro/index.html @@ -1474,6 +1474,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/linux_basics/linux_server_administration/index.html b/level101/linux_basics/linux_server_administration/index.html index d35aaa3..8cf9eb7 100644 --- a/level101/linux_basics/linux_server_administration/index.html +++ b/level101/linux_basics/linux_server_administration/index.html @@ -1677,6 +1677,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/linux_networking/conclusion/index.html b/level101/linux_networking/conclusion/index.html index a2a7df8..4b76aa3 100644 --- a/level101/linux_networking/conclusion/index.html +++ b/level101/linux_networking/conclusion/index.html @@ -1369,6 +1369,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/linux_networking/dns/index.html b/level101/linux_networking/dns/index.html index ebc349e..50f6645 100644 --- a/level101/linux_networking/dns/index.html +++ b/level101/linux_networking/dns/index.html @@ -1398,6 +1398,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/linux_networking/http/index.html b/level101/linux_networking/http/index.html index 25a164d..8544ea1 100644 --- a/level101/linux_networking/http/index.html +++ b/level101/linux_networking/http/index.html @@ -1369,6 +1369,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/linux_networking/intro/index.html b/level101/linux_networking/intro/index.html index ebc47bc..bae50ca 100644 --- a/level101/linux_networking/intro/index.html +++ b/level101/linux_networking/intro/index.html @@ -1426,6 +1426,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/linux_networking/ipr/index.html b/level101/linux_networking/ipr/index.html index ce54a7a..8b122b1 100644 --- a/level101/linux_networking/ipr/index.html +++ b/level101/linux_networking/ipr/index.html @@ -1398,6 +1398,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/linux_networking/tcp/index.html b/level101/linux_networking/tcp/index.html index e5421c6..d4da312 100644 --- a/level101/linux_networking/tcp/index.html +++ b/level101/linux_networking/tcp/index.html @@ -1398,6 +1398,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/linux_networking/udp/index.html b/level101/linux_networking/udp/index.html index 28cce81..21e82eb 100644 --- a/level101/linux_networking/udp/index.html +++ b/level101/linux_networking/udp/index.html @@ -1398,6 +1398,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/metrics_and_monitoring/alerts/index.html b/level101/metrics_and_monitoring/alerts/index.html index 8c3edfe..66b6e3a 100644 --- a/level101/metrics_and_monitoring/alerts/index.html +++ b/level101/metrics_and_monitoring/alerts/index.html @@ -1367,6 +1367,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/metrics_and_monitoring/best_practices/index.html b/level101/metrics_and_monitoring/best_practices/index.html index e6f2af4..8adc7ba 100644 --- a/level101/metrics_and_monitoring/best_practices/index.html +++ b/level101/metrics_and_monitoring/best_practices/index.html @@ -1367,6 +1367,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/metrics_and_monitoring/command-line_tools/index.html b/level101/metrics_and_monitoring/command-line_tools/index.html index b135f7c..f963204 100644 --- a/level101/metrics_and_monitoring/command-line_tools/index.html +++ b/level101/metrics_and_monitoring/command-line_tools/index.html @@ -1367,6 +1367,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/metrics_and_monitoring/conclusion/index.html b/level101/metrics_and_monitoring/conclusion/index.html index fc9f27a..49ef82f 100644 --- a/level101/metrics_and_monitoring/conclusion/index.html +++ b/level101/metrics_and_monitoring/conclusion/index.html @@ -1396,6 +1396,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/metrics_and_monitoring/introduction/index.html b/level101/metrics_and_monitoring/introduction/index.html index 093092b..e542ece 100644 --- a/level101/metrics_and_monitoring/introduction/index.html +++ b/level101/metrics_and_monitoring/introduction/index.html @@ -1367,6 +1367,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/metrics_and_monitoring/observability/index.html b/level101/metrics_and_monitoring/observability/index.html index 91e83e4..6b74820 100644 --- a/level101/metrics_and_monitoring/observability/index.html +++ b/level101/metrics_and_monitoring/observability/index.html @@ -1367,6 +1367,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/metrics_and_monitoring/third-party_monitoring/index.html b/level101/metrics_and_monitoring/third-party_monitoring/index.html index d4a841b..af923c0 100644 --- a/level101/metrics_and_monitoring/third-party_monitoring/index.html +++ b/level101/metrics_and_monitoring/third-party_monitoring/index.html @@ -1367,6 +1367,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/python_web/intro/index.html b/level101/python_web/intro/index.html index f0e3112..d50971d 100644 --- a/level101/python_web/intro/index.html +++ b/level101/python_web/intro/index.html @@ -1451,6 +1451,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/python_web/python-concepts/index.html b/level101/python_web/python-concepts/index.html index 7aadb8f..3a40c52 100644 --- a/level101/python_web/python-concepts/index.html +++ b/level101/python_web/python-concepts/index.html @@ -1430,6 +1430,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/python_web/python-web-flask/index.html b/level101/python_web/python-web-flask/index.html index 127894c..92677a2 100644 --- a/level101/python_web/python-web-flask/index.html +++ b/level101/python_web/python-web-flask/index.html @@ -1403,6 +1403,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/python_web/sre-conclusion/index.html b/level101/python_web/sre-conclusion/index.html index 016e4de..3caf556 100644 --- a/level101/python_web/sre-conclusion/index.html +++ b/level101/python_web/sre-conclusion/index.html @@ -1424,6 +1424,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/python_web/url-shorten-app/index.html b/level101/python_web/url-shorten-app/index.html index 57f7e62..5eb592b 100644 --- a/level101/python_web/url-shorten-app/index.html +++ b/level101/python_web/url-shorten-app/index.html @@ -1437,6 +1437,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/security/conclusion/index.html b/level101/security/conclusion/index.html index fb94bc3..522de0a 100644 --- a/level101/security/conclusion/index.html +++ b/level101/security/conclusion/index.html @@ -1403,6 +1403,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/security/fundamentals/index.html b/level101/security/fundamentals/index.html index 5cec0a3..704b1c8 100644 --- a/level101/security/fundamentals/index.html +++ b/level101/security/fundamentals/index.html @@ -1491,6 +1491,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/security/intro/index.html b/level101/security/intro/index.html index 10625e8..3474ffe 100644 --- a/level101/security/intro/index.html +++ b/level101/security/intro/index.html @@ -1417,6 +1417,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/security/network_security/index.html b/level101/security/network_security/index.html index 4d1d0c0..6752bee 100644 --- a/level101/security/network_security/index.html +++ b/level101/security/network_security/index.html @@ -1602,6 +1602,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/security/threats_attacks_defences/index.html b/level101/security/threats_attacks_defences/index.html index 8b9896f..59fa529 100644 --- a/level101/security/threats_attacks_defences/index.html +++ b/level101/security/threats_attacks_defences/index.html @@ -1650,6 +1650,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/security/writing_secure_code/index.html b/level101/security/writing_secure_code/index.html index 343a59f..8c85b5f 100644 --- a/level101/security/writing_secure_code/index.html +++ b/level101/security/writing_secure_code/index.html @@ -1472,6 +1472,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/systems_design/availability/index.html b/level101/systems_design/availability/index.html index 39e3ce6..25af46e 100644 --- a/level101/systems_design/availability/index.html +++ b/level101/systems_design/availability/index.html @@ -1477,6 +1477,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/systems_design/conclusion/index.html b/level101/systems_design/conclusion/index.html index ac0f493..07fea46 100644 --- a/level101/systems_design/conclusion/index.html +++ b/level101/systems_design/conclusion/index.html @@ -1367,6 +1367,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/systems_design/fault-tolerance/index.html b/level101/systems_design/fault-tolerance/index.html index 0288371..ebf1dc9 100644 --- a/level101/systems_design/fault-tolerance/index.html +++ b/level101/systems_design/fault-tolerance/index.html @@ -1450,6 +1450,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/systems_design/intro/index.html b/level101/systems_design/intro/index.html index bfb5bcf..503254a 100644 --- a/level101/systems_design/intro/index.html +++ b/level101/systems_design/intro/index.html @@ -1431,6 +1431,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level101/systems_design/scalability/index.html b/level101/systems_design/scalability/index.html index 50b3019..f2123e9 100644 --- a/level101/systems_design/scalability/index.html +++ b/level101/systems_design/scalability/index.html @@ -1572,6 +1572,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level102/containerization_and_orchestration/conclusion/index.html b/level102/containerization_and_orchestration/conclusion/index.html index 6e0ce24..63db6c1 100644 --- a/level102/containerization_and_orchestration/conclusion/index.html +++ b/level102/containerization_and_orchestration/conclusion/index.html @@ -1369,6 +1369,106 @@ + + + + + +
  • + + + + + + +
    • + + + @@ -1485,13 +1585,13 @@ -
  • +
    • + + + diff --git a/level102/containerization_and_orchestration/intro/index.html b/level102/containerization_and_orchestration/intro/index.html index d3f81e4..35808d9 100644 --- a/level102/containerization_and_orchestration/intro/index.html +++ b/level102/containerization_and_orchestration/intro/index.html @@ -1432,6 +1432,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level102/containerization_and_orchestration/intro_to_containers/index.html b/level102/containerization_and_orchestration/intro_to_containers/index.html index 358714a..54e6ef3 100644 --- a/level102/containerization_and_orchestration/intro_to_containers/index.html +++ b/level102/containerization_and_orchestration/intro_to_containers/index.html @@ -1462,6 +1462,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level102/containerization_and_orchestration/orchestration_with_kubernetes/index.html b/level102/containerization_and_orchestration/orchestration_with_kubernetes/index.html index d86b33c..0d31989 100644 --- a/level102/containerization_and_orchestration/orchestration_with_kubernetes/index.html +++ b/level102/containerization_and_orchestration/orchestration_with_kubernetes/index.html @@ -1462,6 +1462,106 @@ + + + + + +
  • + + + + + + +
    • + + + diff --git a/level102/system_troubleshooting_and_performance/conclusion/index.html b/level102/system_troubleshooting_and_performance/conclusion/index.html new file mode 100644 index 0000000..681dc73 --- /dev/null +++ b/level102/system_troubleshooting_and_performance/conclusion/index.html @@ -0,0 +1,1698 @@ + + + + + + + + + + + + + + + + + Conclusion - School Of SRE + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + + + + Skip to content + + +
    +
    + +
    + + + + + + +
    + +
    + +
    + + + + +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + +
    +
    +
    + + +
    +
    + + + +

    Conclusion

    + +

    Complex systems have many factors which can go wrong. It can be a bad design & architecture, poorly managed code, poor policies around different caches, bad DB queries or architecture, improper use of resources, or bad OS version, poorly monitored system, datacenter issues, network faults, and many more, Any of these can go wrong.

    +

    As an SRE, Knowing important tools/commands, best practices, profiling, benchmarking and scaling can help you with faster troubleshooting and performance improvement of the overall system.

    +

    Further readings

    +

    Here are some links from the LinkedIn Engineering Blog, as written by LinkedIn engineers, about firefighting they did, ensuring site up 24x7x365.

    + + + + + + + + +
    +
    +
    +
    + + + + +
    + + + + + + + + + \ No newline at end of file diff --git a/level102/system_troubleshooting_and_performance/images/FlaskCode.png b/level102/system_troubleshooting_and_performance/images/FlaskCode.png new file mode 100644 index 0000000000000000000000000000000000000000..6ded2c3974ae23d592745bfe5549b5e908f9de9f GIT binary patch literal 208487 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%0D1Z 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%0Ds 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 Nk-=I0iqrOy{{#2^(Aoe1 literal 0 HcmV?d00001 diff --git a/level102/system_troubleshooting_and_performance/images/MemUsage01.png b/level102/system_troubleshooting_and_performance/images/MemUsage01.png new file mode 100644 index 0000000000000000000000000000000000000000..951694d0e930f93b407227ebc112eebb320f0969 GIT binary patch literal 49329 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 L8Ee+5JIDSPT#AI_ literal 0 HcmV?d00001 diff --git a/level102/system_troubleshooting_and_performance/images/MemUsage02.png b/level102/system_troubleshooting_and_performance/images/MemUsage02.png new file mode 100644 index 0000000000000000000000000000000000000000..5217a332b3fd0f9e716791f63b5f7658a8ee0e63 GIT binary patch literal 208660 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πoB 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

    Vcb#FDn3CRYOWd*_j1zfr!}&48qASa4 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ȋA{YA7KG?;WUTJKtX=DcK;Xbf!y>wP!X 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%0AKIFt{ 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 uvIchls$9{Dl~4 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 literal 0 HcmV?d00001 diff --git a/level102/system_troubleshooting_and_performance/images/MemUsageChart.png b/level102/system_troubleshooting_and_performance/images/MemUsageChart.png new file mode 100644 index 0000000000000000000000000000000000000000..5d099ec30e6dd3c3539c375b803976fe91dd9dec GIT binary patch literal 23960 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

    IC~)jdq08!F+QCFLIt^vhqL%c|xl47v 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 Da);33 literal 0 HcmV?d00001 diff --git a/level102/system_troubleshooting_and_performance/images/Tracemalloc02.png b/level102/system_troubleshooting_and_performance/images/Tracemalloc02.png new file mode 100644 index 0000000000000000000000000000000000000000..1ea88458046b9b648eae21ce1cdf38b2c4cb9822 GIT binary patch literal 58211 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 literal 0 HcmV?d00001 diff --git a/level102/system_troubleshooting_and_performance/images/Tracemalloc03.png b/level102/system_troubleshooting_and_performance/images/Tracemalloc03.png new file mode 100644 index 0000000000000000000000000000000000000000..161fa021631d74d81113518acc61c84d69d25ff8 GIT binary patch literal 46557 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
  • + + + + + + +
    • + + +
  • +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 + + + + + + + + + + + + + + + Important Tools - School Of SRE + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + +
    + + + + + + +
    + +
    + +
    + + + + +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + +
    +
    +
    + + +
    +
    + + + +

    Important Tools

    + +

    Important linux commands

    +

    Having knowledge of following commands will help find issues faster. Elaborating each command in detail is out of scope, please look for man pages or online for more information and examples around the same.

    +
      +
    • For logs parsing -: grep, sed, awk, cut, tail, head
      • +
    • For network checks -: nc, netstat, traceroute/6, mtr, ping/6, route, tcpdump, ss, ip
      • +
    • For DNS -: dig, host, nslookup
      • +
    • For tracing system call -: strace
      • +
    • For parallel executions over ssh -: gnu parallel, xargs + ssh.
      • +
    • For http/s checks -: curl, wget
      • +
    • For list of open files -: lsof
      • +
    • For modifying attributes of the system kernel -: sysctl
      • +
    +

    In case of distributed systems, some good third party tools can help to execute commands/instructions on many hosts at once, like:

    +
      +
    • SSH based tools
        +
      • ClusterSSH: Cluster ssh can help you run a command in parallel on many hosts at once.
        • +
      • Ansible: It allows you to write ansible playbooks which you can run on hundreds/thousands of hosts at the same time.
        • +
      +
      • +
    • Agent Based tools
        +
      • Saltstack: Is a configuration, state and remote execution framework, provides a wide variety of flexibility to users to execute modules on large numbers of hosts at once.
        • +
      • Puppet: Is an automated administrative engine for your Linux, Unix, and Windows systems, performs administrative tasks.
        • +
      +
      • +
    +

    Log analysis tools

    +

    These can help in writing SQL type queries for parsing, analysing logs and provide an easy UI interface to create dashboards which can render various types of charts based on defined queries.

    +
      +
    • ELK: Elasticsearch, Logstash and Kibana, provide package of tools and services to allow, parse logs, index logs and analyse logs easily and quickly. Once logs/data is parsed/filtered through logstash and indexed in elasticsearch, one can create dynamic dashboards in Kibana in a matter of minutes. Such provides easy analysis and correlation on application errors/exceptions/warnings.
      • +
    • Azure kusto: Azure kusto is a cloud based service similar to Elasticsearch and Kibana, it allows easy indexing of heavy logs, provides SQL type interface for writing queries, and an interface to create dynamic dashboards.
      • +
    + + + + + + + +
    +
    +
    +
    + + + + +
    + + + + + + + + + \ No newline at end of file diff --git a/level102/system_troubleshooting_and_performance/introduction/index.html b/level102/system_troubleshooting_and_performance/introduction/index.html new file mode 100644 index 0000000..034ed53 --- /dev/null +++ b/level102/system_troubleshooting_and_performance/introduction/index.html @@ -0,0 +1,1841 @@ + + + + + + + + + + + + + + + + + Introduction - School Of SRE + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + +
    + + + + + + +
    + +
    + +
    + + + + +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + +
    +
    +
    + + +
    +
    + + + +

    System troubleshooting and performance improvements

    +

    Prerequisites

    + +

    What to expect from this course

    +

    This brief course tries to provide a general introduction on how to troubleshoot system issues, like analysing api failures, +resource utilization, network issues, hardware and OS issues. Course also briefs on profiling and benchmarking to measure overall system performance.

    +

    What is not covered under this course

    +

    This course does not cover following -:

    +
      +
    • System Design and Architecture.
      • +
    • Programming practices.
      • +
    • Metrics and Monitoring.
      • +
    • OS basics.
      • +
    +

    Course Contents

    + +

    Introduction

    +

    Troubleshooting is an important part of operations & development. It can’t be learned by just reading one article or completing a course online, +Its a continuous learning process, one learns it during :-

    +
      +
    • Daily operations and development.
      • +
    • Finding & Fixing application bugs.
      • +
    • Finding & Fixing system & network issues.
      • +
    • Performance analysis and improvements.
      • +
    • And more.
      • +
    +

    From an SRE’s perspective, It is expected that they are aware of certain topics upfront to be able to troubleshoot problems around single or distributed systems.

    +
      +
    • Know your resources well, understand host specifications, liks CPU, Memory, Network, Disk etc.
      • +
    • Understand system design and architecture.
      • +
    • Ensure important metrics are being collected/rendered properly.
      • +
    +

    There was a famous quote by HP founders - “What gets measured gets fixed”

    +

    If system components and performance metrics are captured thoroughly then there is a high chance of success in troubleshooting an issue, at its earliest.

    +

    Scope

    +

    There is no common approach to troubleshoot different types of applications or services, the failure can occur at any layer of it. We will keep the scope of this work to a web api service type only.

    +

    Note -: Linux ecosystem is wide, there are hundreds of tools and utilities which can help with system troubleshooting, each comes with its own set of benefits and functionalities. We will cover some of the known tools, either already available with Linux or are available in the open source world. Detailed explanation of mentioned tools in this doc is out of scope, please explore the internet or man pages for more examples and documentation around the same.

    + + + + + + + +
    +
    +
    +
    + + + + +
    + + + + + + + + + \ No newline at end of file diff --git a/level102/system_troubleshooting_and_performance/performance-improvements/index.html b/level102/system_troubleshooting_and_performance/performance-improvements/index.html new file mode 100644 index 0000000..641f244 --- /dev/null +++ b/level102/system_troubleshooting_and_performance/performance-improvements/index.html @@ -0,0 +1,1776 @@ + + + + + + + + + + + + + + + + + Performance Improvements - School Of SRE + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + +
    + + + + + + +
    + +
    + +
    + + + + +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + +
    +
    +
    + + +
    +
    + + + +

    Performance Improvements

    + +

    Performance tools are an important part of development/operations lifecycle, Its highly important for understanding application behavior. SRE generally uses such tools to evaluate how well service will perform and make/suggest improvements accordingly.

    +

    Performance analysis commands

    +

    Most of these commands are a must to know for doing performance analysis of a system or service.

    +
      +
    • top -: shows real-time view of running system, processes, threads etc.
      • +
    • htop -: Similar to top command, but a bit more interactive then it.
      • +
    • iotop -: An interactive disk I/O monitoring tool.
      • +
    • vmstat -: Virtual memory statistics explorer.
      • +
    • iostat -: Monitoring tool for input/output statistics for devices and partitions.
      • +
    • free -: Tell info about physical memory and swap memory.
      • +
    • sar -: System activity report, reports diff metrics such as cpu, disk, mem, network, etc.
      • +
    • mpstat -: Display info about CPU utilization and performance.
      • +
    • lsof -: Provides info about the list of open files, opened by which processes.
      • +
    • perf -: Performance analysing tool.
      • +
    +

    Profiling tools

    +

    Profiling is an important part of performance analysis of the service. There are various profiler tools available, which can help figure most frequent code-paths, debugging, memory profiling, etc. These can generate the heatmap to understand the code performance when under load.

    +
      +
    • FlameGraph: Flame graphs are a visualization of profiled software, allowing the most frequent code-paths to be identified quickly and accurately.
      • +
    • Valgrind: It is a programming tool for memory debugging, memory leak detection, and profiling.
      • +
    • Gprof: GNU profiler tool uses a hybrid of instrumentation and sampling. Instrumentation is used to collect function call information, and sampling is used to gather runtime profiling information.
      • +
    +

    To know how LinkedIn performs On-Demand Profiling on its services, Read LinkedIn blog ODP: An Infrastructure for On-Demand Service Profiling

    +

    Benchmarking

    +

    It is a process of measuring the best performance of the service. Like how much QPS service can handle, its latency when load is increasing, host resource utilization, loadavg etc etc. The regression testing (i.e load testing) is a must before deploying the service to production.

    +

    Some of known tools -:

    +
      +
    • Apache Benchmark Tool, ab:, It simulate a high load on webapp and gather data for analysis
      • +
    • Httperf: It sends requests to the web server at a specified rate and gathers stats. Increase till one finds the saturation point.
      • +
    • Apache JMeter: It is a popular open-source tool to measure web application performance. JMeter is a java based application and not only a web server, but you can use it against PHP, Java, REST, etc.
      • +
    • Wrk: It is another modern performance measurement tool to put a load on your web server and give you latency, request per second, transfer per second, etc. details.
      • +
    • Locust: Easy to use, scriptable and scalable performance testing tool.
      • +
    +

    Limitation -:

    +

    Above tools help in synthetic load or stress testing, but such does not measure actual end user experience, It can’t see how end user resources will affect application performance, it is due to lack of memory, CPU, or poor connectivity to the internet.

    +

    To know how LinkedIn performs load testing across its fleet. Read : Eliminating toil with fully automated load testing

    +

    And to know how LinkedIn makes use of Real Time Monitoring (RUM) data to overcome the limitations of load testing, and help improve overall experience for end users. Read : Monitor and Improve Web Performance Using RUM Data Visualization

    +

    Scaling

    +

    System designed optimally can perform up to a certain limit only, based on availability of resources. Continuous optimization is always needed to ensure optimum use of resources at its peak. With increasing QPS, Systems need to scale up. We can either scale vertically or horizontally. Vertical scalability has its limits as one can increase cpu, memory, disk, GPU and other specifications to certain limit only, whereas horizontal scalability can grow easily and infinitely given limitations imposed by application design and environment attributes.

    +

    Scaling a web application will require some or all of the following -:

    +
      +
    • Ease the server load by adding more hosts.
      • +
    • Distributing the traffic across servers by using Load Balancers.
      • +
    • Scale up DB by sharding the data and increasing read replicas.
      • +
    +

    Here’s a good read how LinkedIn scaled its application stack A Brief History of Scaling LinkedIn

    + + + + + + + +
    +
    +
    +
    + + + + +
    + + + + + + + + + \ No newline at end of file diff --git a/level102/system_troubleshooting_and_performance/troubleshooting-example/index.html b/level102/system_troubleshooting_and_performance/troubleshooting-example/index.html new file mode 100644 index 0000000..6fbc82b --- /dev/null +++ b/level102/system_troubleshooting_and_performance/troubleshooting-example/index.html @@ -0,0 +1,1719 @@ + + + + + + + + + + + + + + + + + Troubleshooting Example - School Of SRE + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + +
    + + + + + + +
    + +
    + +
    + + + + +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + +
    +
    +
    + + +
    +
    + + + +

    Troubleshooting Example

    + +

    In this section we will see an example of an issue and try to troubleshoot it, and at the end a few famous troubleshooting stories are shared, which were shared by LinkedIn engineers earlier.

    +

    Example - Memory leak :

    +

    Often memory leak issues go unnoticed until the service becomes unresponsive after running for some time (days, week or even month) until service is restarted or bug is fixed, In such cases, service memory usage will reflect in increasing order in the metric graph, something like this graph.

    +

    +

    Memory leak is mismanagement of memory allocations by application, where unneeded memory is not released, over the period of time objects continue to pile up in memory resulting in service crash. Generally such non-released objects get sorted by garbage collector automatically, but sometimes due to a bug it fails. Debugging helps in figuring where much of the application storage memory is being applied. Then, you start tracking and filter everything based on usage. In case, you find objects that aren’t in use, but are referenced, you can get rid of them by deleting them to avoid memory leaks. In the case of python applications, it comes with inbuilt features like tracemalloc. This module can help pinpoint where an object was allocated first. Almost every language comes with a set of tools/libraries (inbuilt or external) which helps find memory issues. Similarly for Java there is a famous memory leak detection tool called Java VisualVM.

    +

    Let’s see how a dummy flask based web app with a memory leak bug, with every request its memory usage keeps increasing, and how we can use tracemalloc to capture the leak.

    +

    Assumption -: A python virtual environment is created, and flask is installed in it.

    +

    A bare minimum flask code with bug, read comments for more info +

    +

    Starting flask app +

    +

    On start, Its memory usage is around 26576 kb, i.e approx 26MB +

    +

    Now with every subsequent GET request, We can notice that process memory usage continues to increase slowly. +

    +

    Now lets try 10000 requests, to see if memory usage increases heavily. +To hit a high number of requests, we use an Apache benchmarking tool called “ab”. After 10000 hits, we can notice memory usage of flask app is jumped almost 15 times, i.e from initial 26576 KB to 419316 KB, i.e from roughly 26 MB to 419 MB, That’s a huge jump for such a small webapp. +

    +

    Lets try the python tracemalloc module to try to understand the application memory allocations. Tracemalloc takes memory snapshots at a particular point, performing various statistics on the same.

    +

    Adding a bare minimum code to our app.py file, no change in fetchuserdata.py file, it will allow us to capture tracemalloc snapshots whenever we will hit /capture uri. +

    +

    After restart of app.py (flask run), we will +- First hit http://127.0.0.1:5000/capture +- Then hit http://127.0.0.1:5000/ 10000 times, for memory leak/s to take place. +- Finally hit http://127.0.0.1:5000/capture again to take a snapshot to know which line has the most allocation. +

    +

    In the final snapshot, we noticed the exact module and lineno where most allocation happened. I.e fetchuserdata.py, line no 6, after 10000 hits, it is holding 419 MB of memory. +

    +

    Summary

    +

    Above example shows how a bug can lead to memory leak, and how we can use tracemalloc to understand where it is. In real world applications are way more complex than the above dummy example, you must understand that using tracemalloc might degrade application performance somebit, due to tracemalloc own overheads. Be mindful about its use in production environments.

    +

    If you are interested in digging deeper into Python Object Memory Allocation Internals and debugging memory leak, have a look at an Interesting talk by Sanket Patel in PyCon India 2019, Debug Memory Leak In Python Flask | Python Object Memory Allocation Internals

    + + + + + + + +
    +
    +
    +
    + + + + +
    + + + + + + + + + \ No newline at end of file diff --git a/level102/system_troubleshooting_and_performance/troubleshooting/index.html b/level102/system_troubleshooting_and_performance/troubleshooting/index.html new file mode 100644 index 0000000..f2c1fef --- /dev/null +++ b/level102/system_troubleshooting_and_performance/troubleshooting/index.html @@ -0,0 +1,1759 @@ + + + + + + + + + + + + + + + + + Troubleshooting - School Of SRE + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    + +
    + + + + + + +
    + +
    + +
    + + + + +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + +
    +
    +
    + + +
    +
    + + + +

    Troubleshooting

    + +

    Troubleshooting system failures can be tricky or tedious at times. In this practice we need to examine the end-to-end flow of a service, all its downstreams, analysing logs, memory leak, CPU usage, disk IO, network failures, hosts issues, etc. Knowing certain practices and tools can help figure & mitigate failures faster. Here’s the high level troubleshooting flowchart -:

    +

    Troubleshooting Flowchart

    +

    +

    General Practices

    +

    Different systems require different approaches for finding issues. Scope of this is limited and given a problem, there can be many more points which can be looked into. Following points will look at some high level practices towards finding webapp failures and finding fixes for the same.

    +

    Reproduce problem

    +
      +
    • Try the broken request to reproduce the issue, Like try Hit http/s request which fails.
      • +
    • Check the end to end flow of request and look for return codes, mostly 3xx, 4xx or 5xx. 3xx are mostly about redirections, 4xx are about unauthorized, bad request, forbidden, etc, And 5xx is mostly about server side issues. Based on the return code you can look for the next step.
      • +
    • Client side issues are mainly about missing or buggy static contents, like javascript issues, bad image, broken json from an async call etc, such can result in incorrect page rendering on browsers.
      • +
    +

    Gather Information

    +
      +
    • Look for errors/exceptions in application logs, Like "Can’t Allocate Memory" or OutOfMemoryError, Or Something like "disk I/O error", Or a DNS resolution error.
      • +
    • Check application and host metrics, Look for anomalies in service and hosts graphs. Since when CPU usage has increased, since when memory usage increased, since when disk space is reduced Or Disk I/O is increased, when load average start shooting up etc. Please read the School of SRE link for more detail around metrics and monitoring.
      • +
    • Look for recent code or config changes which possibly are breaking the system.
      • +
    +

    Understand the problem

    +
      +
    • Try correlating gathered data with recent actions, like an exception showing up in logs after config/code deployment.
      • +
    • Is it due to the QPS increase? Is it bad SQL queries? Do recent code changes demand better or more hardware?
      • +
    +

    Find a solution and apply a fix

    +
      +
    • Based on the above findings, look for a quick fix if possible, For example like rolling back changes if errors/exceptions correlate.
      • +
    • Try patching or hotfixing the code, probably in staging setup if you want to fix forward.
      • +
    • Try to scale up the system, if high QPS is the reason for system failure, then try adding resources (compute, storage, memory, etc) as necessary.
      • +
    • Optimize SQL queries if needed.
      • +
    +

    Verify complete request flow

    +
      +
    • Hit requests again and ensure returns are successful (return code 2xx).
      • +
    • Check Logs ensure no more exceptions/errors, as found earlier.
      • +
    • Ensure metrics are back to normal.
      • +
    +

    General Host issues

    +

    To Know if host health is fine or not, look for any hardware failures or its performance issues, one can try following -:

    +
      +
    • Dmesg -: Shows recent errors / failures thrown by kernel. This help with knowing hardware failures if any
      • +
    • ls commands -: lspci, lsblk, lscpu, lsscsi, These commands list out pci, disk, cpu information.
      • +
    • /var/log/messages -: Shows system app/service related errors/warnings, also shows kernel issues.
      • +
    • Smartd -: check disk health.
      • +
    + + + + + + + +
    +
    +
    +
    + + + + +
    + + + + + + + + + \ No newline at end of file diff --git a/search/search_index.json b/search/search_index.json index 1ecfc18..0a0228a 100644 --- a/search/search_index.json +++ b/search/search_index.json @@ -1 +1 @@ -{"config":{"lang":["en"],"min_search_length":3,"prebuild_index":false,"separator":"[\\s\\-]+"},"docs":[{"location":"","text":"School of SRE In early 2019, we started visiting campuses across India to recruit the best and brightest minds to ensure LinkedIn, and all the services that make up its complex technology stack are always available for everyone. This critical function at LinkedIn falls under the purview of the Site Engineering team and Site Reliability Engineers (SREs) who are Software Engineers specializing in reliability. SREs apply the principles of computer science and engineering to the design, development, and operation of computer systems: generally, large-scale, distributed ones. As we continued on this journey we started getting a lot of questions from these campuses on what exactly the site reliability engineering role entails? And, how could someone learn the skills and the disciplines involved to become a successful site reliability engineer? Fast forward a few months, and a few of these campus students had joined LinkedIn either as interns or as full-time engineers to become a part of the Site Engineering team; we also had a few lateral hires who joined our organization who were not from a traditional SRE background. That's when a few of us got together and started to think about how we can onboard new graduate engineers to the Site Engineering team. There is a vast amount of resources scattered throughout the web on what the roles and responsibilities of SREs are, how to monitor site health, production incidents, define SLO/SLI, etc. But there are very few resources out there guiding someone on the basic skill sets one has to acquire as a beginner. Because of the lack of these resources, we felt that individuals have a tough time getting into open positions in the industry. We created the School Of SRE as a starting point for anyone wanting to build their career as an SRE. In this course, we are focusing on building strong foundational skills. The course is structured in a way to provide more real life examples and how learning each of these topics can play an important role in day to day SRE life. Currently we are covering the following topics under the School Of SRE: Fundamentals Series Linux Basics Git Linux Networking Python and Web Data Relational databases(MySQL) NoSQL concepts Big Data Systems Design Metrics and Monitoring Security We believe continuous learning will help in acquiring deeper knowledge and competencies in order to expand your skill sets, every module has added references that could be a guide for further learning. Our hope is that by going through these modules we should be able to build the essential skills required for a Site Reliability Engineer. At LinkedIn, we are using this curriculum for onboarding our non-traditional hires and new college grads into the SRE role. We had multiple rounds of successful onboarding experiences with new employees and the course helped them be productive in a very short period of time. This motivated us to open source the content for helping other organizations in onboarding new engineers into the role and provide guidance for aspiring individuals to get into the role. We realize that the initial content we created is just a starting point and we hope that the community can help in the journey of refining and expanding the content. Check out the contributing guide to get started.","title":"Home"},{"location":"#school-of-sre","text":"In early 2019, we started visiting campuses across India to recruit the best and brightest minds to ensure LinkedIn, and all the services that make up its complex technology stack are always available for everyone. This critical function at LinkedIn falls under the purview of the Site Engineering team and Site Reliability Engineers (SREs) who are Software Engineers specializing in reliability. SREs apply the principles of computer science and engineering to the design, development, and operation of computer systems: generally, large-scale, distributed ones. As we continued on this journey we started getting a lot of questions from these campuses on what exactly the site reliability engineering role entails? And, how could someone learn the skills and the disciplines involved to become a successful site reliability engineer? Fast forward a few months, and a few of these campus students had joined LinkedIn either as interns or as full-time engineers to become a part of the Site Engineering team; we also had a few lateral hires who joined our organization who were not from a traditional SRE background. That's when a few of us got together and started to think about how we can onboard new graduate engineers to the Site Engineering team. There is a vast amount of resources scattered throughout the web on what the roles and responsibilities of SREs are, how to monitor site health, production incidents, define SLO/SLI, etc. But there are very few resources out there guiding someone on the basic skill sets one has to acquire as a beginner. Because of the lack of these resources, we felt that individuals have a tough time getting into open positions in the industry. We created the School Of SRE as a starting point for anyone wanting to build their career as an SRE. In this course, we are focusing on building strong foundational skills. The course is structured in a way to provide more real life examples and how learning each of these topics can play an important role in day to day SRE life. Currently we are covering the following topics under the School Of SRE: Fundamentals Series Linux Basics Git Linux Networking Python and Web Data Relational databases(MySQL) NoSQL concepts Big Data Systems Design Metrics and Monitoring Security We believe continuous learning will help in acquiring deeper knowledge and competencies in order to expand your skill sets, every module has added references that could be a guide for further learning. Our hope is that by going through these modules we should be able to build the essential skills required for a Site Reliability Engineer. At LinkedIn, we are using this curriculum for onboarding our non-traditional hires and new college grads into the SRE role. We had multiple rounds of successful onboarding experiences with new employees and the course helped them be productive in a very short period of time. This motivated us to open source the content for helping other organizations in onboarding new engineers into the role and provide guidance for aspiring individuals to get into the role. We realize that the initial content we created is just a starting point and we hope that the community can help in the journey of refining and expanding the content. Check out the contributing guide to get started.","title":"School of SRE"},{"location":"CODE_OF_CONDUCT/","text":"This code of conduct outlines expectations for participation in LinkedIn-managed open source communities, as well as steps for reporting unacceptable behavior. We are committed to providing a welcoming and inspiring community for all. People violating this code of conduct may be banned from the community. Our open source communities strive to: Be friendly and patient: Remember you might not be communicating in someone else's primary spoken or programming language, and others may not have your level of understanding. Be welcoming: Our communities welcome and support people of all backgrounds and identities. This includes, but is not limited to members of any race, ethnicity, culture, national origin, color, immigration status, social and economic class, educational level, sex, sexual orientation, gender identity and expression, age, size, family status, political belief, religion, and mental and physical ability. Be respectful: We are a world-wide community of professionals, and we conduct ourselves professionally. Disagreement is no excuse for poor behavior and poor manners. Disrespectful and unacceptable behavior includes, but is not limited to: Violent threats or language. Discriminatory or derogatory jokes and language. Posting sexually explicit or violent material. Posting, or threatening to post, people's personally identifying information (\"doxing\"). Insults, especially those using discriminatory terms or slurs. Behavior that could be perceived as sexual attention. Advocating for or encouraging any of the above behaviors. Understand disagreements: Disagreements, both social and technical, are useful learning opportunities. Seek to understand the other viewpoints and resolve differences constructively. This code is not exhaustive or complete. It serves to capture our common understanding of a productive, collaborative environment. We expect the code to be followed in spirit as much as in the letter. Scope This code of conduct applies to all repos and communities for LinkedIn-managed open source projects regardless of whether or not the repo explicitly calls out its use of this code. The code also applies in public spaces when an individual is representing a project or its community. Examples include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. Note: Some LinkedIn-managed communities have codes of conduct that pre-date this document and issue resolution process. While communities are not required to change their code, they are expected to use the resolution process outlined here. The review team will coordinate with the communities involved to address your concerns. Reporting Code of Conduct Issues We encourage all communities to resolve issues on their own whenever possible. This builds a broader and deeper understanding and ultimately a healthier interaction. In the event that an issue cannot be resolved locally, please feel free to report your concerns by contacting oss@linkedin.com . In your report please include: Your contact information. Names (real, usernames or pseudonyms) of any individuals involved. If there are additional witnesses, please include them as well. Your account of what occurred, and if you believe the incident is ongoing. If there is a publicly available record (e.g. a mailing list archive or a public chat log), please include a link or attachment. Any additional information that may be helpful. All reports will be reviewed by a multi-person team and will result in a response that is deemed necessary and appropriate to the circumstances. Where additional perspectives are needed, the team may seek insight from others with relevant expertise or experience. The confidentiality of the person reporting the incident will be kept at all times. Involved parties are never part of the review team. Anyone asked to stop unacceptable behavior is expected to comply immediately. If an individual engages in unacceptable behavior, the review team may take any action they deem appropriate, including a permanent ban from the community. This code of conduct is based on the Microsoft Open Source Code of Conduct which was based on the template established by the TODO Group and used by numerous other large communities (e.g., Facebook , Yahoo , Twitter , GitHub ) and the Scope section from the Contributor Covenant version 1.4 .","title":"Code of Conduct"},{"location":"CODE_OF_CONDUCT/#scope","text":"This code of conduct applies to all repos and communities for LinkedIn-managed open source projects regardless of whether or not the repo explicitly calls out its use of this code. The code also applies in public spaces when an individual is representing a project or its community. Examples include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. Note: Some LinkedIn-managed communities have codes of conduct that pre-date this document and issue resolution process. While communities are not required to change their code, they are expected to use the resolution process outlined here. The review team will coordinate with the communities involved to address your concerns.","title":"Scope"},{"location":"CODE_OF_CONDUCT/#reporting-code-of-conduct-issues","text":"We encourage all communities to resolve issues on their own whenever possible. This builds a broader and deeper understanding and ultimately a healthier interaction. In the event that an issue cannot be resolved locally, please feel free to report your concerns by contacting oss@linkedin.com . In your report please include: Your contact information. Names (real, usernames or pseudonyms) of any individuals involved. If there are additional witnesses, please include them as well. Your account of what occurred, and if you believe the incident is ongoing. If there is a publicly available record (e.g. a mailing list archive or a public chat log), please include a link or attachment. Any additional information that may be helpful. All reports will be reviewed by a multi-person team and will result in a response that is deemed necessary and appropriate to the circumstances. Where additional perspectives are needed, the team may seek insight from others with relevant expertise or experience. The confidentiality of the person reporting the incident will be kept at all times. Involved parties are never part of the review team. Anyone asked to stop unacceptable behavior is expected to comply immediately. If an individual engages in unacceptable behavior, the review team may take any action they deem appropriate, including a permanent ban from the community. This code of conduct is based on the Microsoft Open Source Code of Conduct which was based on the template established by the TODO Group and used by numerous other large communities (e.g., Facebook , Yahoo , Twitter , GitHub ) and the Scope section from the Contributor Covenant version 1.4 .","title":"Reporting Code of Conduct Issues"},{"location":"CONTRIBUTING/","text":"We realise that the initial content we created is just a starting point and our hope is that the community can help in the journey refining and extending the contents. As a contributor, you represent that the content you submit is not plagiarised. By submitting the content, you (and, if applicable, your employer) are licensing the submitted content to LinkedIn and the open source community subject to the Creative Commons Attribution 4.0 International Public License. Repository URL : https://github.com/linkedin/school-of-sre Contributing Guidelines Ensure that you adhere to the following guidelines: Should be about principles and concepts that can be applied in any company or individual project. Do not focus on particular tools or tech stack(which usually change over time). Adhere to the Code of Conduct . Should be relevant to the roles and responsibilities of an SRE. Should be locally tested (see steps for testing) and well formatted. It is good practice to open an issue first and discuss your changes before submitting a pull request. This way, you can incorporate ideas from others before you even start. Building and testing locally Run the following commands to build and view the site locally before opening a PR. python3 -m venv .venv source .venv/bin/activate pip install -r requirements.txt mkdocs build mkdocs serve Opening a PR Follow the GitHub PR workflow for your contributions. Fork this repo, create a feature branch, commit your changes and open a PR to this repo.","title":"Contribute"},{"location":"CONTRIBUTING/#contributing-guidelines","text":"Ensure that you adhere to the following guidelines: Should be about principles and concepts that can be applied in any company or individual project. Do not focus on particular tools or tech stack(which usually change over time). Adhere to the Code of Conduct . Should be relevant to the roles and responsibilities of an SRE. Should be locally tested (see steps for testing) and well formatted. It is good practice to open an issue first and discuss your changes before submitting a pull request. This way, you can incorporate ideas from others before you even start.","title":"Contributing Guidelines"},{"location":"CONTRIBUTING/#building-and-testing-locally","text":"Run the following commands to build and view the site locally before opening a PR. python3 -m venv .venv source .venv/bin/activate pip install -r requirements.txt mkdocs build mkdocs serve","title":"Building and testing locally"},{"location":"CONTRIBUTING/#opening-a-pr","text":"Follow the GitHub PR workflow for your contributions. Fork this repo, create a feature branch, commit your changes and open a PR to this repo.","title":"Opening a PR"},{"location":"sre_community/","text":"We are having an active LinkedIn community for School of SRE. Please join the group via : https://www.linkedin.com/groups/12493545/ The group has members with different levels of experience in site reliability engineering. There are active conversation on different technical topics centered around site reliability engineering. We encourage everyone to join the conversation and learn from each other and build a successful career in the SRE space.","title":"SRE Community"},{"location":"level101/big_data/evolution/","text":"Evolution of Hadoop Architecture of Hadoop HDFS The Hadoop Distributed File System (HDFS) is a distributed file system designed to run on commodity hardware. It has many similarities with existing distributed file systems. However, the differences from other distributed file systems are significant. HDFS is highly fault-tolerant and is designed to be deployed on low-cost hardware. HDFS provides high throughput access to application data and is suitable for applications that have large data sets. HDFS is part of the Apache Hadoop Core project . NameNode: is the arbitrator and central repository of file namespace in the cluster. The NameNode executes the operations such as opening, closing, and renaming files and directories. DataNode: manages the storage attached to the node on which it runs. It is responsible for serving all the read and writes requests. It performs operations on instructions on NameNode such as creation, deletion, and replications of blocks. Client: Responsible for getting the required metadata from the namenode and then communicating with the datanodes for reads and writes. YARN YARN stands for \u201cYet Another Resource Negotiator\u201c. It was introduced in Hadoop 2.0 to remove the bottleneck on Job Tracker which was present in Hadoop 1.0. YARN was described as a \u201cRedesigned Resource Manager\u201d at the time of its launching, but it has now evolved to be known as a large-scale distributed operating system used for Big Data processing. The main components of YARN architecture include: Client: It submits map-reduce(MR) jobs to the resource manager. Resource Manager: It is the master daemon of YARN and is responsible for resource assignment and management among all the applications. Whenever it receives a processing request, it forwards it to the corresponding node manager and allocates resources for the completion of the request accordingly. It has two major components: Scheduler: It performs scheduling based on the allocated application and available resources. It is a pure scheduler, which means that it does not perform other tasks such as monitoring or tracking and does not guarantee a restart if a task fails. The YARN scheduler supports plugins such as Capacity Scheduler and Fair Scheduler to partition the cluster resources. Application manager: It is responsible for accepting the application and negotiating the first container from the resource manager. It also restarts the Application Manager container if a task fails. Node Manager: It takes care of individual nodes on the Hadoop cluster and manages application and workflow and that particular node. Its primary job is to keep up with the Node Manager. It monitors resource usage, performs log management, and also kills a container based on directions from the resource manager. It is also responsible for creating the container process and starting it at the request of the Application master. Application Master: An application is a single job submitted to a framework. The application manager is responsible for negotiating resources with the resource manager, tracking the status, and monitoring the progress of a single application. The application master requests the container from the node manager by sending a Container Launch Context(CLC) which includes everything an application needs to run. Once the application is started, it sends the health report to the resource manager from time-to-time. Container: It is a collection of physical resources such as RAM, CPU cores, and disk on a single node. The containers are invoked by Container Launch Context(CLC) which is a record that contains information such as environment variables, security tokens, dependencies, etc. MapReduce framework The term MapReduce represents two separate and distinct tasks Hadoop programs perform-Map Job and Reduce Job. Map jobs take data sets as input and process them to produce key-value pairs. Reduce job takes the output of the Map job i.e. the key-value pairs and aggregates them to produce desired results. Hadoop MapReduce (Hadoop Map/Reduce) is a software framework for distributed processing of large data sets on computing clusters. Mapreduce helps to split the input data set into a number of parts and run a program on all data parts parallel at once. Please find the below Word count example demonstrating the usage of the MapReduce framework: Other tooling around Hadoop Hive Uses a language called HQL which is very SQL like. Gives non-programmers the ability to query and analyze data in Hadoop. Is basically an abstraction layer on top of map-reduce. Ex. HQL query: SELECT pet.name, comment FROM pet JOIN event ON (pet.name = event.name); In mysql: SELECT pet.name, comment FROM pet, event WHERE pet.name = event.name; Pig Uses a scripting language called Pig Latin, which is more workflow driven. Don't need to be an expert Java programmer but need a few coding skills. Is also an abstraction layer on top of map-reduce. Here is a quick question for you: What is the output of running the pig queries in the right column against the data present in the left column in the below image? Output: 7,Komal,Nayak,24,9848022334,trivendram 8,Bharathi,Nambiayar,24,9848022333,Chennai 5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 6,Archana,Mishra,23,9848022335,Chennai Spark Spark provides primitives for in-memory cluster computing that allows user programs to load data into a cluster\u2019s memory and query it repeatedly, making it well suited to machine learning algorithms. Presto Presto is a high performance, distributed SQL query engine for Big Data. Its architecture allows users to query a variety of data sources such as Hadoop, AWS S3, Alluxio, MySQL, Cassandra, Kafka, and MongoDB. Example presto query: use studentDB; show tables; SELECT roll_no, name FROM studentDB.studentDetails where section=\u2019A\u2019 limit 5; Data Serialisation and storage In order to transport the data over the network or to store on some persistent storage, we use the process of translating data structures or objects state into binary or textual form. We call this process serialization.. Avro data is stored in a container file (a .avro file) and its schema (the .avsc file) is stored with the data file. Apache Hive provides support to store a table as Avro and can also query data in this serialisation format.","title":"Evolution and Architecture of Hadoop"},{"location":"level101/big_data/evolution/#evolution-of-hadoop","text":"","title":"Evolution of Hadoop"},{"location":"level101/big_data/evolution/#architecture-of-hadoop","text":"HDFS The Hadoop Distributed File System (HDFS) is a distributed file system designed to run on commodity hardware. It has many similarities with existing distributed file systems. However, the differences from other distributed file systems are significant. HDFS is highly fault-tolerant and is designed to be deployed on low-cost hardware. HDFS provides high throughput access to application data and is suitable for applications that have large data sets. HDFS is part of the Apache Hadoop Core project . NameNode: is the arbitrator and central repository of file namespace in the cluster. The NameNode executes the operations such as opening, closing, and renaming files and directories. DataNode: manages the storage attached to the node on which it runs. It is responsible for serving all the read and writes requests. It performs operations on instructions on NameNode such as creation, deletion, and replications of blocks. Client: Responsible for getting the required metadata from the namenode and then communicating with the datanodes for reads and writes. YARN YARN stands for \u201cYet Another Resource Negotiator\u201c. It was introduced in Hadoop 2.0 to remove the bottleneck on Job Tracker which was present in Hadoop 1.0. YARN was described as a \u201cRedesigned Resource Manager\u201d at the time of its launching, but it has now evolved to be known as a large-scale distributed operating system used for Big Data processing. The main components of YARN architecture include: Client: It submits map-reduce(MR) jobs to the resource manager. Resource Manager: It is the master daemon of YARN and is responsible for resource assignment and management among all the applications. Whenever it receives a processing request, it forwards it to the corresponding node manager and allocates resources for the completion of the request accordingly. It has two major components: Scheduler: It performs scheduling based on the allocated application and available resources. It is a pure scheduler, which means that it does not perform other tasks such as monitoring or tracking and does not guarantee a restart if a task fails. The YARN scheduler supports plugins such as Capacity Scheduler and Fair Scheduler to partition the cluster resources. Application manager: It is responsible for accepting the application and negotiating the first container from the resource manager. It also restarts the Application Manager container if a task fails. Node Manager: It takes care of individual nodes on the Hadoop cluster and manages application and workflow and that particular node. Its primary job is to keep up with the Node Manager. It monitors resource usage, performs log management, and also kills a container based on directions from the resource manager. It is also responsible for creating the container process and starting it at the request of the Application master. Application Master: An application is a single job submitted to a framework. The application manager is responsible for negotiating resources with the resource manager, tracking the status, and monitoring the progress of a single application. The application master requests the container from the node manager by sending a Container Launch Context(CLC) which includes everything an application needs to run. Once the application is started, it sends the health report to the resource manager from time-to-time. Container: It is a collection of physical resources such as RAM, CPU cores, and disk on a single node. The containers are invoked by Container Launch Context(CLC) which is a record that contains information such as environment variables, security tokens, dependencies, etc.","title":"Architecture of Hadoop"},{"location":"level101/big_data/evolution/#mapreduce-framework","text":"The term MapReduce represents two separate and distinct tasks Hadoop programs perform-Map Job and Reduce Job. Map jobs take data sets as input and process them to produce key-value pairs. Reduce job takes the output of the Map job i.e. the key-value pairs and aggregates them to produce desired results. Hadoop MapReduce (Hadoop Map/Reduce) is a software framework for distributed processing of large data sets on computing clusters. Mapreduce helps to split the input data set into a number of parts and run a program on all data parts parallel at once. Please find the below Word count example demonstrating the usage of the MapReduce framework:","title":"MapReduce framework"},{"location":"level101/big_data/evolution/#other-tooling-around-hadoop","text":"Hive Uses a language called HQL which is very SQL like. Gives non-programmers the ability to query and analyze data in Hadoop. Is basically an abstraction layer on top of map-reduce. Ex. HQL query: SELECT pet.name, comment FROM pet JOIN event ON (pet.name = event.name); In mysql: SELECT pet.name, comment FROM pet, event WHERE pet.name = event.name; Pig Uses a scripting language called Pig Latin, which is more workflow driven. Don't need to be an expert Java programmer but need a few coding skills. Is also an abstraction layer on top of map-reduce. Here is a quick question for you: What is the output of running the pig queries in the right column against the data present in the left column in the below image? Output: 7,Komal,Nayak,24,9848022334,trivendram 8,Bharathi,Nambiayar,24,9848022333,Chennai 5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 6,Archana,Mishra,23,9848022335,Chennai Spark Spark provides primitives for in-memory cluster computing that allows user programs to load data into a cluster\u2019s memory and query it repeatedly, making it well suited to machine learning algorithms. Presto Presto is a high performance, distributed SQL query engine for Big Data. Its architecture allows users to query a variety of data sources such as Hadoop, AWS S3, Alluxio, MySQL, Cassandra, Kafka, and MongoDB. Example presto query: use studentDB; show tables; SELECT roll_no, name FROM studentDB.studentDetails where section=\u2019A\u2019 limit 5;","title":"Other tooling around Hadoop"},{"location":"level101/big_data/evolution/#data-serialisation-and-storage","text":"In order to transport the data over the network or to store on some persistent storage, we use the process of translating data structures or objects state into binary or textual form. We call this process serialization.. Avro data is stored in a container file (a .avro file) and its schema (the .avsc file) is stored with the data file. Apache Hive provides support to store a table as Avro and can also query data in this serialisation format.","title":"Data Serialisation and storage"},{"location":"level101/big_data/intro/","text":"Big Data Prerequisites Basics of Linux File systems. Basic understanding of System Design. What to expect from this course This course covers the basics of Big Data and how it has evolved to become what it is today. We will take a look at a few realistic scenarios where Big Data would be a perfect fit. An interesting assignment on designing a Big Data system is followed by understanding the architecture of Hadoop and the tooling around it. What is not covered under this course Writing programs to draw analytics from data. Course Contents Overview of Big Data Usage of Big Data techniques Evolution of Hadoop Architecture of hadoop HDFS Yarn MapReduce framework Other tooling around hadoop Hive Pig Spark Presto Data Serialisation and storage Overview of Big Data Big Data is a collection of large datasets that cannot be processed using traditional computing techniques. It is not a single technique or a tool, rather it has become a complete subject, which involves various tools, techniques, and frameworks. Big Data could consist of Structured data Unstructured data Semi-structured data Characteristics of Big Data: Volume Variety Velocity Variability Examples of Big Data generation include stock exchanges, social media sites, jet engines, etc. Usage of Big Data Techniques Take the example of the traffic lights problem. There are more than 300,000 traffic lights in the US as of 2018. Let us assume that we placed a device on each of them to collect metrics and send it to a central metrics collection system. If each of the IoT devices sends 10 events per minute, we have 300000x10x60x24 = 432x10^7 events per day. How would you go about processing that and telling me how many of the signals were \u201cgreen\u201d at 10:45 am on a particular day? Consider the next example on Unified Payments Interface (UPI) transactions: We had about 1.15 billion UPI transactions in the month of October 2019 in India. If we try to extrapolate this data to about a year and try to find out some common payments that were happening through a particular UPI ID, how do you suggest we go about that?","title":"Introduction"},{"location":"level101/big_data/intro/#big-data","text":"","title":"Big Data"},{"location":"level101/big_data/intro/#prerequisites","text":"Basics of Linux File systems. Basic understanding of System Design.","title":"Prerequisites"},{"location":"level101/big_data/intro/#what-to-expect-from-this-course","text":"This course covers the basics of Big Data and how it has evolved to become what it is today. We will take a look at a few realistic scenarios where Big Data would be a perfect fit. An interesting assignment on designing a Big Data system is followed by understanding the architecture of Hadoop and the tooling around it.","title":"What to expect from this course"},{"location":"level101/big_data/intro/#what-is-not-covered-under-this-course","text":"Writing programs to draw analytics from data.","title":"What is not covered under this course"},{"location":"level101/big_data/intro/#course-contents","text":"Overview of Big Data Usage of Big Data techniques Evolution of Hadoop Architecture of hadoop HDFS Yarn MapReduce framework Other tooling around hadoop Hive Pig Spark Presto Data Serialisation and storage","title":"Course Contents"},{"location":"level101/big_data/intro/#overview-of-big-data","text":"Big Data is a collection of large datasets that cannot be processed using traditional computing techniques. It is not a single technique or a tool, rather it has become a complete subject, which involves various tools, techniques, and frameworks. Big Data could consist of Structured data Unstructured data Semi-structured data Characteristics of Big Data: Volume Variety Velocity Variability Examples of Big Data generation include stock exchanges, social media sites, jet engines, etc.","title":"Overview of Big Data"},{"location":"level101/big_data/intro/#usage-of-big-data-techniques","text":"Take the example of the traffic lights problem. There are more than 300,000 traffic lights in the US as of 2018. Let us assume that we placed a device on each of them to collect metrics and send it to a central metrics collection system. If each of the IoT devices sends 10 events per minute, we have 300000x10x60x24 = 432x10^7 events per day. How would you go about processing that and telling me how many of the signals were \u201cgreen\u201d at 10:45 am on a particular day? Consider the next example on Unified Payments Interface (UPI) transactions: We had about 1.15 billion UPI transactions in the month of October 2019 in India. If we try to extrapolate this data to about a year and try to find out some common payments that were happening through a particular UPI ID, how do you suggest we go about that?","title":"Usage of Big Data Techniques"},{"location":"level101/big_data/tasks/","text":"Tasks and conclusion Post-training tasks: Try setting up your own 3 node Hadoop cluster. A VM based solution can be found here Write a simple spark/MR job of your choice and understand how to generate analytics from data. Sample dataset can be found here References: Hadoop documentation HDFS Architecture YARN Architecture Google GFS paper","title":"Conclusion"},{"location":"level101/big_data/tasks/#tasks-and-conclusion","text":"","title":"Tasks and conclusion"},{"location":"level101/big_data/tasks/#post-training-tasks","text":"Try setting up your own 3 node Hadoop cluster. A VM based solution can be found here Write a simple spark/MR job of your choice and understand how to generate analytics from data. Sample dataset can be found here","title":"Post-training tasks:"},{"location":"level101/big_data/tasks/#references","text":"Hadoop documentation HDFS Architecture YARN Architecture Google GFS paper","title":"References:"},{"location":"level101/databases_nosql/further_reading/","text":"Conclusion We have covered basic concepts of NoSQL databases. There is much more to learn and do. We hope this course gives you a good start and inspires you to explore further. Further reading NoSQL: https://hostingdata.co.uk/nosql-database/ https://www.mongodb.com/nosql-explained https://www.mongodb.com/nosql-explained/nosql-vs-sql Cap Theorem http://www.julianbrowne.com/article/brewers-cap-theorem Scalability http://www.slideshare.net/jboner/scalability-availability-stability-patterns Eventual Consistency https://www.allthingsdistributed.com/2008/12/eventually_consistent.html https://www.toptal.com/big-data/consistent-hashing https://web.stanford.edu/class/cs244/papers/chord_TON_2003.pdf","title":"Conclusion"},{"location":"level101/databases_nosql/further_reading/#conclusion","text":"We have covered basic concepts of NoSQL databases. There is much more to learn and do. We hope this course gives you a good start and inspires you to explore further.","title":"Conclusion"},{"location":"level101/databases_nosql/further_reading/#further-reading","text":"NoSQL: https://hostingdata.co.uk/nosql-database/ https://www.mongodb.com/nosql-explained https://www.mongodb.com/nosql-explained/nosql-vs-sql Cap Theorem http://www.julianbrowne.com/article/brewers-cap-theorem Scalability http://www.slideshare.net/jboner/scalability-availability-stability-patterns Eventual Consistency https://www.allthingsdistributed.com/2008/12/eventually_consistent.html https://www.toptal.com/big-data/consistent-hashing https://web.stanford.edu/class/cs244/papers/chord_TON_2003.pdf","title":"Further reading"},{"location":"level101/databases_nosql/intro/","text":"NoSQL Concepts Prerequisites Relational Databases What to expect from this course At the end of training, you will have an understanding of what a NoSQL database is, what kind of advantages or disadvantages it has over traditional RDBMS, learn about different types of NoSQL databases and understand some of the underlying concepts & trade offs w.r.t to NoSQL. What is not covered under this course We will not be deep diving into any specific NoSQL Database. Course Contents Introduction to NoSQL CAP Theorem Data versioning Partitioning Hashing Quorum Introduction When people use the term \u201cNoSQL database\u201d, they typically use it to refer to any non-relational database. Some say the term \u201cNoSQL\u201d stands for \u201cnon SQL\u201d while others say it stands for \u201cnot only SQL.\u201d Either way, most agree that NoSQL databases are databases that store data in a format other than relational tables. A common misconception is that NoSQL databases or non-relational databases don\u2019t store relationship data well. NoSQL databases can store relationship data\u2014they just store it differently than relational databases do. In fact, when compared with SQL databases, many find modeling relationship data in NoSQL databases to be easier , because related data doesn\u2019t have to be split between tables. Such databases have existed since the late 1960s, but the name \"NoSQL\" was only coined in the early 21st century. NASA used a NoSQL database to track inventory for the Apollo mission. NoSQL databases emerged in the late 2000s as the cost of storage dramatically decreased. Gone were the days of needing to create a complex, difficult-to-manage data model simply for the purposes of reducing data duplication. Developers (rather than storage) were becoming the primary cost of software development, so NoSQL databases optimized for developer productivity. With the rise of Agile development methodology, NoSQL databases were developed with a focus on scaling, fast performance and at the same time allowed for frequent application changes and made programming easier. Types of NoSQL databases: Over time due to the way these NoSQL databases were developed to suit requirements at different companies, we ended up with quite a few types of them. However, they can be broadly classified into 4 types. Some of the databases can overlap between different types. They are Document databases: They store data in documents similar to JSON (JavaScript Object Notation) objects. Each document contains pairs of fields and values. The values can typically be a variety of types including things like strings, numbers, booleans, arrays, or objects, and their structures typically align with objects developers are working with in code. The advantages include intuitive data model & flexible schemas. Because of their variety of field value types and powerful query languages, document databases are great for a wide variety of use cases and can be used as a general purpose database. They can horizontally scale-out to accomodate large data volumes. Ex: MongoDB, Couchbase Key-Value databases: These are a simpler type of databases where each item contains keys and values. A value can typically only be retrieved by referencing its key, so learning how to query for a specific key-value pair is typically simple. Key-value databases are great for use cases where you need to store large amounts of data but you don\u2019t need to perform complex queries to retrieve it. Common use cases include storing user preferences or caching. Ex: Redis , DynamoDB , Voldemort / Venice (Linkedin), Wide-Column stores: They store data in tables, rows, and dynamic columns. Wide-column stores provide a lot of flexibility over relational databases because each row is not required to have the same columns. Many consider wide-column stores to be two-dimensional key-value databases. Wide-column stores are great for when you need to store large amounts of data and you can predict what your query patterns will be. Wide-column stores are commonly used for storing Internet of Things data and user profile data. Cassandra and HBase are two of the most popular wide-column stores. Graph Databases: These databases store data in nodes and edges. Nodes typically store information about people, places, and things while edges store information about the relationships between the nodes. The underlying storage mechanism of graph databases can vary. Some depend on a relational engine and \u201cstore\u201d the graph data in a table (although a table is a logical element, therefore this approach imposes another level of abstraction between the graph database, the graph database management system and the physical devices where the data is actually stored). Others use a key-value store or document-oriented database for storage, making them inherently NoSQL structures. Graph databases excel in use cases where you need to traverse relationships to look for patterns such as social networks, fraud detection, and recommendation engines. Ex: Neo4j Comparison Performance Scalability Flexibility Complexity Functionality Key Value high high high none Variable Document stores high Variable (high) high low Variable (low) Column DB high high moderate low minimal Graph Variable Variable high high Graph theory Differences between SQL and NoSQL The table below summarizes the main differences between SQL and NoSQL databases. SQL Databases NoSQL Databases Data Storage Model Tables with fixed rows and columns Document: JSON documents, Key-value: key-value pairs, Wide-column: tables with rows and dynamic columns, Graph: nodes and edges Primary Purpose General purpose Document: general purpose, Key-value: large amounts of data with simple lookup queries, Wide-column: large amounts of data with predictable query patterns, Graph: analyzing and traversing relationships between connected data Schemas Rigid Flexible Scaling Vertical (scale-up with a larger server) Horizontal (scale-out across commodity servers) Multi-Record ACID Transactions Supported Most do not support multi-record ACID transactions. However, some\u2014like MongoDB\u2014do. Joins Typically required Typically not required Data to Object Mapping Requires ORM (object-relational mapping) Many do not require ORMs. Document DB documents map directly to data structures in most popular programming languages. Advantages Flexible Data Models Most NoSQL systems feature flexible schemas. A flexible schema means you can easily modify your database schema to add or remove fields to support for evolving application requirements. This facilitates with continuous application development of new features without database operation overhead. Horizontal Scaling Most NoSQL systems allow you to scale horizontally, which means you can add in cheaper & commodity hardware, whenever you want to scale a system. On the other hand SQL systems generally scale Vertically (a more powerful server). NoSQL systems can also host huge data sets when compared to traditional SQL systems. Fast Queries NoSQL can generally be a lot faster than traditional SQL systems due to data denormalization and horizontal scaling. Most NoSQL systems also tend to store similar data together facilitating faster query responses. Developer productivity NoSQL systems tend to map data based on the programming data structures. As a result developers need to perform fewer data transformations leading to increased productivity & fewer bugs.","title":"Introduction"},{"location":"level101/databases_nosql/intro/#nosql-concepts","text":"","title":"NoSQL Concepts"},{"location":"level101/databases_nosql/intro/#prerequisites","text":"Relational Databases","title":"Prerequisites"},{"location":"level101/databases_nosql/intro/#what-to-expect-from-this-course","text":"At the end of training, you will have an understanding of what a NoSQL database is, what kind of advantages or disadvantages it has over traditional RDBMS, learn about different types of NoSQL databases and understand some of the underlying concepts & trade offs w.r.t to NoSQL.","title":"What to expect from this course"},{"location":"level101/databases_nosql/intro/#what-is-not-covered-under-this-course","text":"We will not be deep diving into any specific NoSQL Database.","title":"What is not covered under this course"},{"location":"level101/databases_nosql/intro/#course-contents","text":"Introduction to NoSQL CAP Theorem Data versioning Partitioning Hashing Quorum","title":"Course Contents"},{"location":"level101/databases_nosql/intro/#introduction","text":"When people use the term \u201cNoSQL database\u201d, they typically use it to refer to any non-relational database. Some say the term \u201cNoSQL\u201d stands for \u201cnon SQL\u201d while others say it stands for \u201cnot only SQL.\u201d Either way, most agree that NoSQL databases are databases that store data in a format other than relational tables. A common misconception is that NoSQL databases or non-relational databases don\u2019t store relationship data well. NoSQL databases can store relationship data\u2014they just store it differently than relational databases do. In fact, when compared with SQL databases, many find modeling relationship data in NoSQL databases to be easier , because related data doesn\u2019t have to be split between tables. Such databases have existed since the late 1960s, but the name \"NoSQL\" was only coined in the early 21st century. NASA used a NoSQL database to track inventory for the Apollo mission. NoSQL databases emerged in the late 2000s as the cost of storage dramatically decreased. Gone were the days of needing to create a complex, difficult-to-manage data model simply for the purposes of reducing data duplication. Developers (rather than storage) were becoming the primary cost of software development, so NoSQL databases optimized for developer productivity. With the rise of Agile development methodology, NoSQL databases were developed with a focus on scaling, fast performance and at the same time allowed for frequent application changes and made programming easier.","title":"Introduction"},{"location":"level101/databases_nosql/intro/#types-of-nosql-databases","text":"Over time due to the way these NoSQL databases were developed to suit requirements at different companies, we ended up with quite a few types of them. However, they can be broadly classified into 4 types. Some of the databases can overlap between different types. They are Document databases: They store data in documents similar to JSON (JavaScript Object Notation) objects. Each document contains pairs of fields and values. The values can typically be a variety of types including things like strings, numbers, booleans, arrays, or objects, and their structures typically align with objects developers are working with in code. The advantages include intuitive data model & flexible schemas. Because of their variety of field value types and powerful query languages, document databases are great for a wide variety of use cases and can be used as a general purpose database. They can horizontally scale-out to accomodate large data volumes. Ex: MongoDB, Couchbase Key-Value databases: These are a simpler type of databases where each item contains keys and values. A value can typically only be retrieved by referencing its key, so learning how to query for a specific key-value pair is typically simple. Key-value databases are great for use cases where you need to store large amounts of data but you don\u2019t need to perform complex queries to retrieve it. Common use cases include storing user preferences or caching. Ex: Redis , DynamoDB , Voldemort / Venice (Linkedin), Wide-Column stores: They store data in tables, rows, and dynamic columns. Wide-column stores provide a lot of flexibility over relational databases because each row is not required to have the same columns. Many consider wide-column stores to be two-dimensional key-value databases. Wide-column stores are great for when you need to store large amounts of data and you can predict what your query patterns will be. Wide-column stores are commonly used for storing Internet of Things data and user profile data. Cassandra and HBase are two of the most popular wide-column stores. Graph Databases: These databases store data in nodes and edges. Nodes typically store information about people, places, and things while edges store information about the relationships between the nodes. The underlying storage mechanism of graph databases can vary. Some depend on a relational engine and \u201cstore\u201d the graph data in a table (although a table is a logical element, therefore this approach imposes another level of abstraction between the graph database, the graph database management system and the physical devices where the data is actually stored). Others use a key-value store or document-oriented database for storage, making them inherently NoSQL structures. Graph databases excel in use cases where you need to traverse relationships to look for patterns such as social networks, fraud detection, and recommendation engines. Ex: Neo4j","title":"Types of NoSQL databases:"},{"location":"level101/databases_nosql/intro/#comparison","text":"Performance Scalability Flexibility Complexity Functionality Key Value high high high none Variable Document stores high Variable (high) high low Variable (low) Column DB high high moderate low minimal Graph Variable Variable high high Graph theory","title":"Comparison"},{"location":"level101/databases_nosql/intro/#differences-between-sql-and-nosql","text":"The table below summarizes the main differences between SQL and NoSQL databases. SQL Databases NoSQL Databases Data Storage Model Tables with fixed rows and columns Document: JSON documents, Key-value: key-value pairs, Wide-column: tables with rows and dynamic columns, Graph: nodes and edges Primary Purpose General purpose Document: general purpose, Key-value: large amounts of data with simple lookup queries, Wide-column: large amounts of data with predictable query patterns, Graph: analyzing and traversing relationships between connected data Schemas Rigid Flexible Scaling Vertical (scale-up with a larger server) Horizontal (scale-out across commodity servers) Multi-Record ACID Transactions Supported Most do not support multi-record ACID transactions. However, some\u2014like MongoDB\u2014do. Joins Typically required Typically not required Data to Object Mapping Requires ORM (object-relational mapping) Many do not require ORMs. Document DB documents map directly to data structures in most popular programming languages.","title":"Differences between SQL and NoSQL"},{"location":"level101/databases_nosql/intro/#advantages","text":"Flexible Data Models Most NoSQL systems feature flexible schemas. A flexible schema means you can easily modify your database schema to add or remove fields to support for evolving application requirements. This facilitates with continuous application development of new features without database operation overhead. Horizontal Scaling Most NoSQL systems allow you to scale horizontally, which means you can add in cheaper & commodity hardware, whenever you want to scale a system. On the other hand SQL systems generally scale Vertically (a more powerful server). NoSQL systems can also host huge data sets when compared to traditional SQL systems. Fast Queries NoSQL can generally be a lot faster than traditional SQL systems due to data denormalization and horizontal scaling. Most NoSQL systems also tend to store similar data together facilitating faster query responses. Developer productivity NoSQL systems tend to map data based on the programming data structures. As a result developers need to perform fewer data transformations leading to increased productivity & fewer bugs.","title":"Advantages"},{"location":"level101/databases_nosql/key_concepts/","text":"Key Concepts Lets looks at some of the key concepts when we talk about NoSQL or distributed systems CAP Theorem In a keynote titled \u201c Towards Robust Distributed Systems \u201d at ACM\u2019s PODC symposium in 2000 Eric Brewer came up with the so-called CAP-theorem which is widely adopted today by large web companies as well as in the NoSQL community. The CAP acronym stands for C onsistency, A vailability & P artition Tolerance. Consistency It refers to how consistent a system is after an execution. A distributed system is called consistent when a write made by a source is available for all readers of that shared data. Different NoSQL systems support different levels of consistency. Availability It refers to how a system responds to loss of functionality of different systems due to hardware and software failures. A high availability implies that a system is still available to handle operations (reads and writes) when a certain part of the system is down due to a failure or upgrade. Partition Tolerance It is the ability of the system to continue operations in the event of a network partition. A network partition occurs when a failure causes two or more islands of networks where the systems can\u2019t talk to each other across the islands temporarily or permanently. Brewer alleges that one can at most choose two of these three characteristics in a shared-data system. The CAP-theorem states that a choice can only be made for two options out of consistency, availability and partition tolerance. A growing number of use cases in large scale applications tend to value reliability implying that availability & redundancy are more valuable than consistency. As a result these systems struggle to meet ACID properties. They attain this by loosening on the consistency requirement i.e Eventual Consistency. Eventual Consistency means that all readers will see writes, as time goes on: \u201cIn a steady state, the system will eventually return the last written value\u201d. Clients therefore may face an inconsistent state of data as updates are in progress. For instance, in a replicated database updates may go to one node which replicates the latest version to all other nodes that contain a replica of the modified dataset so that the replica nodes eventually will have the latest version. NoSQL systems support different levels of eventual consistency models. For example: Read Your Own Writes Consistency Clients will see their updates immediately after they are written. The reads can hit nodes other than the one where it was written. However they might not see updates by other clients immediately. Session Consistency Clients will see the updates to their data within a session scope. This generally indicates that reads & writes occur on the same server. Other clients using the same nodes will receive the same updates. Casual Consistency A system provides causal consistency if the following condition holds: write operations that are related by potential causality are seen by each process of the system in order. Different processes may observe concurrent writes in different orders Eventual consistency is useful if concurrent updates of the same partitions of data are unlikely and if clients do not immediately depend on reading updates issued by themselves or by other clients. Depending on what consistency model was chosen for the system (or parts of it), determines where the requests are routed, ex: replicas. CAP alternatives illustration Choice Traits Examples Consistency + Availability (Forfeit Partitions) 2-phase commits Cache invalidation protocols Single-site databases Cluster databases LDAP xFS file system Consistency + Partition tolerance (Forfeit Availability) Pessimistic locking Make minority partitions unavailable Distributed databases Distributed locking Majority protocols Availability + Partition tolerance (Forfeit Consistency) expirations/leases conflict resolution optimistic DNS Web caching Versioning of Data in distributed systems When data is distributed across nodes, it can be modified on different nodes at the same time (assuming strict consistency is enforced). Questions arise on conflict resolution for concurrent updates. Some of the popular conflict resolution mechanism are Timestamps This is the most obvious solution. You sort updates based on chronological order and choose the latest update. However this relies on clock synchronization across different parts of the infrastructure. This gets even more complicated when parts of systems are spread across different geographic locations. Optimistic Locking You associate a unique value like a clock or counter with every data update. When a client wants to update data, it has to specify which version of data needs to be updated. This would mean you need to keep track of history of the data versions. Vector Clocks A vector clock is defined as a tuple of clock values from each node. In a distributed environment, each node maintains a tuple of such clock values which represent the state of the nodes itself and its peers/replicas. A clock value may be real timestamps derived from local clock or version no. Vector clocks illustration Vector clocks have the following advantages over other conflict resolution mechanism No dependency on synchronized clocks No total ordering of revision nos required for casual reasoning No need to store and maintain multiple versions of the data on different nodes. Partitioning When the amount of data crosses the capacity of a single node, we need to think of splitting data, creating replicas for load balancing & disaster recovery. Depending on how dynamic the infrastructure is, we have a few approaches that we can take. Memory cached These are partitioned in-memory databases that are primarily used for transient data. These databases are generally used as a front for traditional RDBMS. Most frequently used data is replicated from a rdbms into a memory database to facilitate fast queries and to take the load off from backend DB\u2019s. A very common example is memcached or couchbase. Clustering Traditional cluster mechanisms abstract away the cluster topology from clients. A client need not know where the actual data is residing and which node it is talking to. Clustering is very commonly used in traditional RDBMS where it can help scaling the persistent layer to a certain extent. Separating reads from writes In this method, you will have multiple replicas hosting the same data. The incoming writes are typically sent to a single node (Leader) or multiple nodes (multi-Leader), while the rest of the replicas (Follower) handle reads requests. The leader replicates writes asynchronously to all followers. However the write lag can\u2019t be completely avoided. Sometimes a leader can crash before it replicates all the data to a follower. When this happens, a follower with the most consistent data can be turned into a leader. As you can realize now, it is hard to enforce full consistency in this model. You also need to consider the ratio of read vs write traffic. This model won\u2019t make sense when writes are higher than reads. The replication methods can also vary widely. Some systems do a complete transfer of state periodically, while others use a delta state transfer approach. You could also transfer the state by transferring the operations in order. The followers can then apply the same operations as the leader to catch up. Sharding Sharing refers to dividing data in such a way that data is distributed evenly (both in terms of storage & processing power) across a cluster of nodes. It can also imply data locality, which means similar & related data is stored together to facilitate faster access. A shard in turn can be further replicated to meet load balancing or disaster recovery requirements. A single shard replica might take in all writes (single leader) or multiple replicas can take writes (multi-leader). Reads can be distributed across multiple replicas. Since data is now distributed across multiple nodes, clients should be able to consistently figure out where data is hosted. We will look at some of the common techniques below. The downside of sharding is that joins between shards is not possible. So an upstream/downstream application has to aggregate the results from multiple shards. Sharding example Hashing A hash function is a function that maps one piece of data\u2014typically describing some kind of object, often of arbitrary size\u2014to another piece of data, typically an integer, known as hash code , or simply hash . In a partitioned database, it is important to consistently map a key to a server/replica. For ex: you can use a very simple hash as a modulo function. _p = k mod n_ Where p -> partition, k -> primary key n -> no of nodes The downside of this simple hash is that, whenever the cluster topology changes, the data distribution also changes. When you are dealing with memory caches, it will be easy to distribute partitions around. Whenever a node joins/leaves a topology, partitions can reorder themselves, a cache miss can be re-populated from backend DB. However when you look at persistent data, it is not possible as the new node doesn\u2019t have the data needed to serve it. This brings us to consistent hashing. Consistent Hashing Consistent hashing is a distributed hashing scheme that operates independently of the number of servers or objects in a distributed hash table by assigning them a position on an abstract circle, or hash ring . This allows servers and objects to scale without affecting the overall system. Say that our hash function h() generates a 32-bit integer. Then, to determine to which server we will send a key k, we find the server s whose hash h(s) is the smallest integer that is larger than h(k). To make the process simpler, we assume the table is circular, which means that if we cannot find a server with a hash larger than h(k), we wrap around and start looking from the beginning of the array. Consistent hashing illustration In consistent hashing when a server is removed or added then only the keys from that server are relocated. For example, if server S3 is removed then, all keys from server S3 will be moved to server S4 but keys stored on server S4 and S2 are not relocated. But there is one problem, when server S3 is removed then keys from S3 are not equally distributed among remaining servers S4 and S2. They are only assigned to server S4 which increases the load on server S4. To evenly distribute the load among servers when a server is added or removed, it creates a fixed number of replicas ( known as virtual nodes) of each server and distributes it along the circle. So instead of server labels S1, S2 and S3, we will have S10 S11\u2026S19, S20 S21\u2026S29 and S30 S31\u2026S39. The factor for a number of replicas is also known as weight , depending on the situation. All keys which are mapped to replicas Sij are stored on server Si. To find a key we do the same thing, find the position of the key on the circle and then move forward until you find a server replica. If the server replica is Sij then the key is stored in server Si. Suppose server S3 is removed, then all S3 replicas with labels S30 S31 \u2026 S39 must be removed. Now the objects keys adjacent to S3X labels will be automatically re-assigned to S1X, S2X and S4X. All keys originally assigned to S1, S2 & S4 will not be moved. Similar things happen if we add a server. Suppose we want to add a server S5 as a replacement of S3 then we need to add labels S50 S51 \u2026 S59. In the ideal case, one-fourth of keys from S1, S2 and S4 will be reassigned to S5. When applied to persistent storages, further issues arise: if a node has left the scene, data stored on this node becomes unavailable, unless it has been replicated to other nodes before; in the opposite case of a new node joining the others, adjacent nodes are no longer responsible for some pieces of data which they still store but not get asked for anymore as the corresponding objects are no longer hashed to them by requesting clients. In order to address this issue, a replication factor (r) can be introduced. Introducing replicas in a partitioning scheme\u2014besides reliability benefits\u2014also makes it possible to spread workload for read requests that can go to any physical node responsible for a requested piece of data. Scalability doesn\u2019t work if the clients have to decide between multiple versions of the dataset, because they need to read from a quorum of servers which in turn reduces the efficiency of load balancing. Quorum Quorum is the minimum number of nodes in a cluster that must be online and be able to communicate with each other. If any additional node failure occurs beyond this threshold, the cluster will stop running. To attain a quorum, you need a majority of the nodes. Commonly it is (N/2 + 1), where N is the total no of nodes in the system. For ex, In a 3 node cluster, you need 2 nodes for a majority, In a 5 node cluster, you need 3 nodes for a majority, In a 6 node cluster, you need 4 nodes for a majority. Quorum example Network problems can cause communication failures among cluster nodes. One set of nodes might be able to communicate together across a functioning part of a network but not be able to communicate with a different set of nodes in another part of the network. This is known as split brain in cluster or cluster partitioning. Now the partition which has quorum is allowed to continue running the application. The other partitions are removed from the cluster. Eg: In a 5 node cluster, consider what happens if nodes 1, 2, and 3 can communicate with each other but not with nodes 4 and 5. Nodes 1, 2, and 3 constitute a majority, and they continue running as a cluster. Nodes 4 and 5, being a minority, stop running as a cluster. If node 3 loses communication with other nodes, all nodes stop running as a cluster. However, all functioning nodes will continue to listen for communication, so that when the network begins working again, the cluster can form and begin to run. Below diagram demonstrates Quorum selection on a cluster partitioned into two sets. Cluster Quorum example","title":"Key Concepts"},{"location":"level101/databases_nosql/key_concepts/#key-concepts","text":"Lets looks at some of the key concepts when we talk about NoSQL or distributed systems","title":"Key Concepts"},{"location":"level101/databases_nosql/key_concepts/#cap-theorem","text":"In a keynote titled \u201c Towards Robust Distributed Systems \u201d at ACM\u2019s PODC symposium in 2000 Eric Brewer came up with the so-called CAP-theorem which is widely adopted today by large web companies as well as in the NoSQL community. The CAP acronym stands for C onsistency, A vailability & P artition Tolerance. Consistency It refers to how consistent a system is after an execution. A distributed system is called consistent when a write made by a source is available for all readers of that shared data. Different NoSQL systems support different levels of consistency. Availability It refers to how a system responds to loss of functionality of different systems due to hardware and software failures. A high availability implies that a system is still available to handle operations (reads and writes) when a certain part of the system is down due to a failure or upgrade. Partition Tolerance It is the ability of the system to continue operations in the event of a network partition. A network partition occurs when a failure causes two or more islands of networks where the systems can\u2019t talk to each other across the islands temporarily or permanently. Brewer alleges that one can at most choose two of these three characteristics in a shared-data system. The CAP-theorem states that a choice can only be made for two options out of consistency, availability and partition tolerance. A growing number of use cases in large scale applications tend to value reliability implying that availability & redundancy are more valuable than consistency. As a result these systems struggle to meet ACID properties. They attain this by loosening on the consistency requirement i.e Eventual Consistency. Eventual Consistency means that all readers will see writes, as time goes on: \u201cIn a steady state, the system will eventually return the last written value\u201d. Clients therefore may face an inconsistent state of data as updates are in progress. For instance, in a replicated database updates may go to one node which replicates the latest version to all other nodes that contain a replica of the modified dataset so that the replica nodes eventually will have the latest version. NoSQL systems support different levels of eventual consistency models. For example: Read Your Own Writes Consistency Clients will see their updates immediately after they are written. The reads can hit nodes other than the one where it was written. However they might not see updates by other clients immediately. Session Consistency Clients will see the updates to their data within a session scope. This generally indicates that reads & writes occur on the same server. Other clients using the same nodes will receive the same updates. Casual Consistency A system provides causal consistency if the following condition holds: write operations that are related by potential causality are seen by each process of the system in order. Different processes may observe concurrent writes in different orders Eventual consistency is useful if concurrent updates of the same partitions of data are unlikely and if clients do not immediately depend on reading updates issued by themselves or by other clients. Depending on what consistency model was chosen for the system (or parts of it), determines where the requests are routed, ex: replicas. CAP alternatives illustration Choice Traits Examples Consistency + Availability (Forfeit Partitions) 2-phase commits Cache invalidation protocols Single-site databases Cluster databases LDAP xFS file system Consistency + Partition tolerance (Forfeit Availability) Pessimistic locking Make minority partitions unavailable Distributed databases Distributed locking Majority protocols Availability + Partition tolerance (Forfeit Consistency) expirations/leases conflict resolution optimistic DNS Web caching","title":"CAP Theorem"},{"location":"level101/databases_nosql/key_concepts/#versioning-of-data-in-distributed-systems","text":"When data is distributed across nodes, it can be modified on different nodes at the same time (assuming strict consistency is enforced). Questions arise on conflict resolution for concurrent updates. Some of the popular conflict resolution mechanism are Timestamps This is the most obvious solution. You sort updates based on chronological order and choose the latest update. However this relies on clock synchronization across different parts of the infrastructure. This gets even more complicated when parts of systems are spread across different geographic locations. Optimistic Locking You associate a unique value like a clock or counter with every data update. When a client wants to update data, it has to specify which version of data needs to be updated. This would mean you need to keep track of history of the data versions. Vector Clocks A vector clock is defined as a tuple of clock values from each node. In a distributed environment, each node maintains a tuple of such clock values which represent the state of the nodes itself and its peers/replicas. A clock value may be real timestamps derived from local clock or version no. Vector clocks illustration Vector clocks have the following advantages over other conflict resolution mechanism No dependency on synchronized clocks No total ordering of revision nos required for casual reasoning No need to store and maintain multiple versions of the data on different nodes.","title":"Versioning of Data in distributed systems"},{"location":"level101/databases_nosql/key_concepts/#partitioning","text":"When the amount of data crosses the capacity of a single node, we need to think of splitting data, creating replicas for load balancing & disaster recovery. Depending on how dynamic the infrastructure is, we have a few approaches that we can take. Memory cached These are partitioned in-memory databases that are primarily used for transient data. These databases are generally used as a front for traditional RDBMS. Most frequently used data is replicated from a rdbms into a memory database to facilitate fast queries and to take the load off from backend DB\u2019s. A very common example is memcached or couchbase. Clustering Traditional cluster mechanisms abstract away the cluster topology from clients. A client need not know where the actual data is residing and which node it is talking to. Clustering is very commonly used in traditional RDBMS where it can help scaling the persistent layer to a certain extent. Separating reads from writes In this method, you will have multiple replicas hosting the same data. The incoming writes are typically sent to a single node (Leader) or multiple nodes (multi-Leader), while the rest of the replicas (Follower) handle reads requests. The leader replicates writes asynchronously to all followers. However the write lag can\u2019t be completely avoided. Sometimes a leader can crash before it replicates all the data to a follower. When this happens, a follower with the most consistent data can be turned into a leader. As you can realize now, it is hard to enforce full consistency in this model. You also need to consider the ratio of read vs write traffic. This model won\u2019t make sense when writes are higher than reads. The replication methods can also vary widely. Some systems do a complete transfer of state periodically, while others use a delta state transfer approach. You could also transfer the state by transferring the operations in order. The followers can then apply the same operations as the leader to catch up. Sharding Sharing refers to dividing data in such a way that data is distributed evenly (both in terms of storage & processing power) across a cluster of nodes. It can also imply data locality, which means similar & related data is stored together to facilitate faster access. A shard in turn can be further replicated to meet load balancing or disaster recovery requirements. A single shard replica might take in all writes (single leader) or multiple replicas can take writes (multi-leader). Reads can be distributed across multiple replicas. Since data is now distributed across multiple nodes, clients should be able to consistently figure out where data is hosted. We will look at some of the common techniques below. The downside of sharding is that joins between shards is not possible. So an upstream/downstream application has to aggregate the results from multiple shards. Sharding example","title":"Partitioning"},{"location":"level101/databases_nosql/key_concepts/#hashing","text":"A hash function is a function that maps one piece of data\u2014typically describing some kind of object, often of arbitrary size\u2014to another piece of data, typically an integer, known as hash code , or simply hash . In a partitioned database, it is important to consistently map a key to a server/replica. For ex: you can use a very simple hash as a modulo function. _p = k mod n_ Where p -> partition, k -> primary key n -> no of nodes The downside of this simple hash is that, whenever the cluster topology changes, the data distribution also changes. When you are dealing with memory caches, it will be easy to distribute partitions around. Whenever a node joins/leaves a topology, partitions can reorder themselves, a cache miss can be re-populated from backend DB. However when you look at persistent data, it is not possible as the new node doesn\u2019t have the data needed to serve it. This brings us to consistent hashing.","title":"Hashing"},{"location":"level101/databases_nosql/key_concepts/#consistent-hashing","text":"Consistent hashing is a distributed hashing scheme that operates independently of the number of servers or objects in a distributed hash table by assigning them a position on an abstract circle, or hash ring . This allows servers and objects to scale without affecting the overall system. Say that our hash function h() generates a 32-bit integer. Then, to determine to which server we will send a key k, we find the server s whose hash h(s) is the smallest integer that is larger than h(k). To make the process simpler, we assume the table is circular, which means that if we cannot find a server with a hash larger than h(k), we wrap around and start looking from the beginning of the array. Consistent hashing illustration In consistent hashing when a server is removed or added then only the keys from that server are relocated. For example, if server S3 is removed then, all keys from server S3 will be moved to server S4 but keys stored on server S4 and S2 are not relocated. But there is one problem, when server S3 is removed then keys from S3 are not equally distributed among remaining servers S4 and S2. They are only assigned to server S4 which increases the load on server S4. To evenly distribute the load among servers when a server is added or removed, it creates a fixed number of replicas ( known as virtual nodes) of each server and distributes it along the circle. So instead of server labels S1, S2 and S3, we will have S10 S11\u2026S19, S20 S21\u2026S29 and S30 S31\u2026S39. The factor for a number of replicas is also known as weight , depending on the situation. All keys which are mapped to replicas Sij are stored on server Si. To find a key we do the same thing, find the position of the key on the circle and then move forward until you find a server replica. If the server replica is Sij then the key is stored in server Si. Suppose server S3 is removed, then all S3 replicas with labels S30 S31 \u2026 S39 must be removed. Now the objects keys adjacent to S3X labels will be automatically re-assigned to S1X, S2X and S4X. All keys originally assigned to S1, S2 & S4 will not be moved. Similar things happen if we add a server. Suppose we want to add a server S5 as a replacement of S3 then we need to add labels S50 S51 \u2026 S59. In the ideal case, one-fourth of keys from S1, S2 and S4 will be reassigned to S5. When applied to persistent storages, further issues arise: if a node has left the scene, data stored on this node becomes unavailable, unless it has been replicated to other nodes before; in the opposite case of a new node joining the others, adjacent nodes are no longer responsible for some pieces of data which they still store but not get asked for anymore as the corresponding objects are no longer hashed to them by requesting clients. In order to address this issue, a replication factor (r) can be introduced. Introducing replicas in a partitioning scheme\u2014besides reliability benefits\u2014also makes it possible to spread workload for read requests that can go to any physical node responsible for a requested piece of data. Scalability doesn\u2019t work if the clients have to decide between multiple versions of the dataset, because they need to read from a quorum of servers which in turn reduces the efficiency of load balancing.","title":"Consistent Hashing"},{"location":"level101/databases_nosql/key_concepts/#quorum","text":"Quorum is the minimum number of nodes in a cluster that must be online and be able to communicate with each other. If any additional node failure occurs beyond this threshold, the cluster will stop running. To attain a quorum, you need a majority of the nodes. Commonly it is (N/2 + 1), where N is the total no of nodes in the system. For ex, In a 3 node cluster, you need 2 nodes for a majority, In a 5 node cluster, you need 3 nodes for a majority, In a 6 node cluster, you need 4 nodes for a majority. Quorum example Network problems can cause communication failures among cluster nodes. One set of nodes might be able to communicate together across a functioning part of a network but not be able to communicate with a different set of nodes in another part of the network. This is known as split brain in cluster or cluster partitioning. Now the partition which has quorum is allowed to continue running the application. The other partitions are removed from the cluster. Eg: In a 5 node cluster, consider what happens if nodes 1, 2, and 3 can communicate with each other but not with nodes 4 and 5. Nodes 1, 2, and 3 constitute a majority, and they continue running as a cluster. Nodes 4 and 5, being a minority, stop running as a cluster. If node 3 loses communication with other nodes, all nodes stop running as a cluster. However, all functioning nodes will continue to listen for communication, so that when the network begins working again, the cluster can form and begin to run. Below diagram demonstrates Quorum selection on a cluster partitioned into two sets. Cluster Quorum example","title":"Quorum"},{"location":"level101/databases_sql/backup_recovery/","text":"Backup and Recovery Backups are a very crucial part of any database setup. They are generally a copy of the data that can be used to reconstruct the data in case of any major or minor crisis with the database. In general terms backups can be of two types:- Physical Backup - the data directory as it is on the disk Logical Backup - the table structure and records in it Both the above kinds of backups are supported by MySQL with different tools. It is the job of the SRE to identify which should be used when. Mysqldump This utility is available with MySQL installation. It helps in getting the logical backup of the database. It outputs a set of SQL statements to reconstruct the data. It is not recommended to use mysqldump for large tables as it might take a lot of time and the file size will be huge. However, for small tables it is the best and the quickest option. mysqldump [options] > dump_output.sql There are certain options that can be used with mysqldump to get an appropriate dump of the database. To dump all the databases mysqldump -u -p --all-databases > all_dbs.sql To dump specific databases mysqldump -u -p --databases db1 db2 db3 > dbs.sql To dump a single database mysqldump -u -p --databases db1 > db1.sql OR mysqldump -u -p db1 > db1.sql The difference between the above two commands is that the latter one does not contain the CREATE DATABASE command in the backup output. To dump specific tables in a database mysqldump -u -p db1 table1 table2 > db1_tables.sql To dump only table structures and no data mysqldump -u -p --no-data db1 > db1_structure.sql To dump only table data and no CREATE statements mysqldump -u -p --no-create-info db1 > db1_data.sql To dump only specific records from a table mysqldump -u -p --no-create-info db1 table1 --where=\u201dsalary>80000\u201d > db1_table1_80000.sql Mysqldump can also provide output in CSV, other delimited text or XML format to support use-cases if any. The backup from mysqldump utility is offline i.e. when the backup finishes it will not have the changes to the database which were made when the backup was going on. For example, if the backup started at 3 PM and finished at 4 PM, it will not have the changes made to the database between 3 and 4 PM. Restoring from mysqldump can be done in the following two ways:- From shell mysql -u -p < all_dbs.sql OR From shell if the database is already created mysql -u -p db1 < db1.sql From within MySQL shell mysql> source all_dbs.sql Percona Xtrabackup This utility is installed separately from the MySQL server and is open source, provided by Percona. It helps in getting the full or partial physical backup of the database. It provides online backup of the database i.e. it will have the changes made to the database when the backup was going on as explained at the end of the previous section. Full Backup - the complete backup of the database. Partial Backup - Incremental Cumulative - After one full backup, the next backups will have changes post the full backup. For example, we took a full backup on Sunday, from Monday onwards every backup will have changes after Sunday; so, Tuesday\u2019s backup will have Monday\u2019s changes as well, Wednesday\u2019s backup will have changes of Monday and Tuesday as well and so on. Differential - After one full backup, the next backups will have changes post the previous incremental backup. For example, we took a full backup on Sunday, Monday will have changes done after Sunday, Tuesday will have changes done after Monday, and so on. Percona xtrabackup allows us to get both full and incremental backups as we desire. However, incremental backups take less space than a full backup (if taken per day) but the restore time of incremental backups is more than that of full backups. Creating a full backup xtrabackup --defaults-file= --user= --password= --backup --target-dir= Example xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/ Some other options --stream - can be used to stream the backup files to standard output in a specified format. xbstream is the only option for now. --tmp-dir - set this to a tmp directory to be used for temporary files while taking backups. --parallel - set this to the number of threads that can be used to parallely copy data files to target directory. --compress - by default - quicklz is used. Set this to have the backup in compressed format. Each file is a .qp compressed file and can be extracted by qpress file archiver. --decompress - decompresses all the files which were compressed with the .qp extension. It will not delete the .qp files after decompression. To do that, use --remove-original along with this. Please note that the decompress option should be run separately from the xtrabackup command that used the compress option. Preparing a backup Once the backup is done with the --backup option, we need to prepare it in order to restore it. This is done to make the datafiles consistent with point-in-time. There might have been some transactions going on while the backup was being executed and those have changed the data files. When we prepare a backup, all those transactions are applied to the data files. xtrabackup --prepare --target-dir= Example xtrabackup --prepare --target-dir=/mnt/data/backup/ It is not recommended to halt a process which is preparing the backup as that might cause data file corruption and backup cannot be used further. The backup will have to be taken again. Restoring a Full Backup To restore the backup which is created and prepared from above commands, just copy everything from the backup target-dir to the data-dir of MySQL server, change the ownership of all files to mysql user (the linux user used by MySQL server) and start mysql. Or the below command can be used as well, xtrabackup --defaults-file=/etc/my.cnf --copy-back --target-dir=/mnt/data/backups/ Note - the backup has to be prepared in order to restore it. Creating Incremental backups Percona Xtrabackup helps create incremental backups, i.e only the changes can be backed up since the last backup. Every InnoDB page contains a log sequence number or LSN that is also mentioned as one of the last lines of backup and prepare commands. xtrabackup: Transaction log of lsn to was copied. OR InnoDB: Shutdown completed; log sequence number completed OK! This indicates that the backup has been taken till the log sequence number mentioned. This is a key information in understanding incremental backups and working towards automating one. Incremental backups do not compare data files for changes, instead, they go through the InnoDB pages and compare their LSN to the last backup\u2019s LSN. So, without one full backup, the incremental backups are useless. The xtrabackup command creates a xtrabackup_checkpoint file which has the information about the LSN of the backup. Below are the key contents of the file:- backup_type = full-backuped | incremental from_lsn = 0 (full backup) | to_lsn of last backup to_lsn = last_lsn = There is a difference between to_lsn and last_lsn . When the last_lsn is more than to_lsn that means there are transactions that ran while we took the backup and are yet to be applied. That is what --prepare is used for. To take incremental backups, first, we require one full backup. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/full/ Let\u2019s assume the contents of the xtrabackup_checkpoint file to be as follows. backup_type = full-backuped from_lsn = 0 to_lsn = 1000 last_lsn = 1000 Now that we have one full backup, we can have an incremental backup that takes the changes. We will go with differential incremental backups. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/incr1/ --incremental-basedir=/mnt/data/backup/full/ There are delta files created in the incr1 directory like, ibdata1.delta , db1/tbl1.ibd.delta with the changes from the full directory. The xtrabackup_checkpoint file will thus have the following contents. backup_type = incremental from_lsn = 1000 to_lsn = 1500 last_lsn = 1500 Hence, the from_lsn here is equal to the to_lsn of the last backup or the basedir provided for the incremental backups. For the next incremental backup we can use this incremental backup as the basedir. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/incr2/ --incremental-basedir=/mnt/data/backup/incr1/ The xtrabackup_checkpoint file will thus have the following contents. backup_type = incremental from_lsn = 1500 to_lsn = 2000 last_lsn = 2200 Preparing Incremental backups Preparing incremental backups is not the same as preparing a full backup. When prepare runs, two operations are performed - committed transactions are applied on the data files and uncommitted transactions are rolled back . While preparing incremental backups, we have to skip rollback of uncommitted transactions as it is likely that they might get committed in the next incremental backup. If we rollback uncommitted transactions the further incremental backups cannot be applied. We use --apply-log-only option along with --prepare to avoid the rollback phase. From the last section, we had the following directories with complete backup /mnt/data/backup/full /mnt/data/backup/incr1 /mnt/data/backup/incr2 First, we prepare the full backup, but only with the --apply-log-only option. xtrabackup --prepare --apply-log-only --target-dir=/mnt/data/backup/full The output of the command will contain the following at the end. InnoDB: Shutdown complete; log sequence number 1000 Completed OK! Note the LSN mentioned at the end is the same as the to_lsn from the xtrabackup_checkpoint created for full backup. Next, we apply the changes from the first incremental backup to the full backup. xtrabackup --prepare --apply-log-only --target-dir=/mnt/data/backup/full --incremental-dir=/mnt/data/backup/incr1 This applies the delta files in the incremental directory to the full backup directory. It rolls the data files in the full backup directory forward to the time of incremental backup and applies the redo logs as usual. Lastly, we apply the last incremental backup same as the previous one with just a small change. xtrabackup --prepare --target-dir=/mnt/data/backup/full --incremental-dir=/mnt/data/backup/incr1 We do not have to use the --apply-log-only option with it. It applies the incr2 delta files to the full backup data files taking them forward, applies redo logs on them and finally rollbacks the uncommitted transactions to produce the final result. The data now present in the full backup directory can now be used to restore. Note - To create cumulative incremental backups, the incremental-basedir should always be the full backup directory for every incremental backup. While preparing, we can start with the full backup with the --apply-log-only option and use just the last incremental backup for the final --prepare as that has all the changes since the full backup. Restoring Incremental backups Once all the above steps are completed, restoring is the same as done for a full backup. Further Reading MySQL Point-In-Time-Recovery Another MySQL backup tool - mysqlpump Another MySQL backup tool - mydumper A comparison between mysqldump, mysqlpump and mydumper Backup Best Practices","title":"Backup and Recovery"},{"location":"level101/databases_sql/backup_recovery/#backup-and-recovery","text":"Backups are a very crucial part of any database setup. They are generally a copy of the data that can be used to reconstruct the data in case of any major or minor crisis with the database. In general terms backups can be of two types:- Physical Backup - the data directory as it is on the disk Logical Backup - the table structure and records in it Both the above kinds of backups are supported by MySQL with different tools. It is the job of the SRE to identify which should be used when.","title":"Backup and Recovery"},{"location":"level101/databases_sql/backup_recovery/#mysqldump","text":"This utility is available with MySQL installation. It helps in getting the logical backup of the database. It outputs a set of SQL statements to reconstruct the data. It is not recommended to use mysqldump for large tables as it might take a lot of time and the file size will be huge. However, for small tables it is the best and the quickest option. mysqldump [options] > dump_output.sql There are certain options that can be used with mysqldump to get an appropriate dump of the database. To dump all the databases mysqldump -u -p --all-databases > all_dbs.sql To dump specific databases mysqldump -u -p --databases db1 db2 db3 > dbs.sql To dump a single database mysqldump -u -p --databases db1 > db1.sql OR mysqldump -u -p db1 > db1.sql The difference between the above two commands is that the latter one does not contain the CREATE DATABASE command in the backup output. To dump specific tables in a database mysqldump -u -p db1 table1 table2 > db1_tables.sql To dump only table structures and no data mysqldump -u -p --no-data db1 > db1_structure.sql To dump only table data and no CREATE statements mysqldump -u -p --no-create-info db1 > db1_data.sql To dump only specific records from a table mysqldump -u -p --no-create-info db1 table1 --where=\u201dsalary>80000\u201d > db1_table1_80000.sql Mysqldump can also provide output in CSV, other delimited text or XML format to support use-cases if any. The backup from mysqldump utility is offline i.e. when the backup finishes it will not have the changes to the database which were made when the backup was going on. For example, if the backup started at 3 PM and finished at 4 PM, it will not have the changes made to the database between 3 and 4 PM. Restoring from mysqldump can be done in the following two ways:- From shell mysql -u -p < all_dbs.sql OR From shell if the database is already created mysql -u -p db1 < db1.sql From within MySQL shell mysql> source all_dbs.sql","title":"Mysqldump"},{"location":"level101/databases_sql/backup_recovery/#percona-xtrabackup","text":"This utility is installed separately from the MySQL server and is open source, provided by Percona. It helps in getting the full or partial physical backup of the database. It provides online backup of the database i.e. it will have the changes made to the database when the backup was going on as explained at the end of the previous section. Full Backup - the complete backup of the database. Partial Backup - Incremental Cumulative - After one full backup, the next backups will have changes post the full backup. For example, we took a full backup on Sunday, from Monday onwards every backup will have changes after Sunday; so, Tuesday\u2019s backup will have Monday\u2019s changes as well, Wednesday\u2019s backup will have changes of Monday and Tuesday as well and so on. Differential - After one full backup, the next backups will have changes post the previous incremental backup. For example, we took a full backup on Sunday, Monday will have changes done after Sunday, Tuesday will have changes done after Monday, and so on. Percona xtrabackup allows us to get both full and incremental backups as we desire. However, incremental backups take less space than a full backup (if taken per day) but the restore time of incremental backups is more than that of full backups. Creating a full backup xtrabackup --defaults-file= --user= --password= --backup --target-dir= Example xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/ Some other options --stream - can be used to stream the backup files to standard output in a specified format. xbstream is the only option for now. --tmp-dir - set this to a tmp directory to be used for temporary files while taking backups. --parallel - set this to the number of threads that can be used to parallely copy data files to target directory. --compress - by default - quicklz is used. Set this to have the backup in compressed format. Each file is a .qp compressed file and can be extracted by qpress file archiver. --decompress - decompresses all the files which were compressed with the .qp extension. It will not delete the .qp files after decompression. To do that, use --remove-original along with this. Please note that the decompress option should be run separately from the xtrabackup command that used the compress option. Preparing a backup Once the backup is done with the --backup option, we need to prepare it in order to restore it. This is done to make the datafiles consistent with point-in-time. There might have been some transactions going on while the backup was being executed and those have changed the data files. When we prepare a backup, all those transactions are applied to the data files. xtrabackup --prepare --target-dir= Example xtrabackup --prepare --target-dir=/mnt/data/backup/ It is not recommended to halt a process which is preparing the backup as that might cause data file corruption and backup cannot be used further. The backup will have to be taken again. Restoring a Full Backup To restore the backup which is created and prepared from above commands, just copy everything from the backup target-dir to the data-dir of MySQL server, change the ownership of all files to mysql user (the linux user used by MySQL server) and start mysql. Or the below command can be used as well, xtrabackup --defaults-file=/etc/my.cnf --copy-back --target-dir=/mnt/data/backups/ Note - the backup has to be prepared in order to restore it. Creating Incremental backups Percona Xtrabackup helps create incremental backups, i.e only the changes can be backed up since the last backup. Every InnoDB page contains a log sequence number or LSN that is also mentioned as one of the last lines of backup and prepare commands. xtrabackup: Transaction log of lsn to was copied. OR InnoDB: Shutdown completed; log sequence number completed OK! This indicates that the backup has been taken till the log sequence number mentioned. This is a key information in understanding incremental backups and working towards automating one. Incremental backups do not compare data files for changes, instead, they go through the InnoDB pages and compare their LSN to the last backup\u2019s LSN. So, without one full backup, the incremental backups are useless. The xtrabackup command creates a xtrabackup_checkpoint file which has the information about the LSN of the backup. Below are the key contents of the file:- backup_type = full-backuped | incremental from_lsn = 0 (full backup) | to_lsn of last backup to_lsn = last_lsn = There is a difference between to_lsn and last_lsn . When the last_lsn is more than to_lsn that means there are transactions that ran while we took the backup and are yet to be applied. That is what --prepare is used for. To take incremental backups, first, we require one full backup. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/full/ Let\u2019s assume the contents of the xtrabackup_checkpoint file to be as follows. backup_type = full-backuped from_lsn = 0 to_lsn = 1000 last_lsn = 1000 Now that we have one full backup, we can have an incremental backup that takes the changes. We will go with differential incremental backups. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/incr1/ --incremental-basedir=/mnt/data/backup/full/ There are delta files created in the incr1 directory like, ibdata1.delta , db1/tbl1.ibd.delta with the changes from the full directory. The xtrabackup_checkpoint file will thus have the following contents. backup_type = incremental from_lsn = 1000 to_lsn = 1500 last_lsn = 1500 Hence, the from_lsn here is equal to the to_lsn of the last backup or the basedir provided for the incremental backups. For the next incremental backup we can use this incremental backup as the basedir. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/incr2/ --incremental-basedir=/mnt/data/backup/incr1/ The xtrabackup_checkpoint file will thus have the following contents. backup_type = incremental from_lsn = 1500 to_lsn = 2000 last_lsn = 2200 Preparing Incremental backups Preparing incremental backups is not the same as preparing a full backup. When prepare runs, two operations are performed - committed transactions are applied on the data files and uncommitted transactions are rolled back . While preparing incremental backups, we have to skip rollback of uncommitted transactions as it is likely that they might get committed in the next incremental backup. If we rollback uncommitted transactions the further incremental backups cannot be applied. We use --apply-log-only option along with --prepare to avoid the rollback phase. From the last section, we had the following directories with complete backup /mnt/data/backup/full /mnt/data/backup/incr1 /mnt/data/backup/incr2 First, we prepare the full backup, but only with the --apply-log-only option. xtrabackup --prepare --apply-log-only --target-dir=/mnt/data/backup/full The output of the command will contain the following at the end. InnoDB: Shutdown complete; log sequence number 1000 Completed OK! Note the LSN mentioned at the end is the same as the to_lsn from the xtrabackup_checkpoint created for full backup. Next, we apply the changes from the first incremental backup to the full backup. xtrabackup --prepare --apply-log-only --target-dir=/mnt/data/backup/full --incremental-dir=/mnt/data/backup/incr1 This applies the delta files in the incremental directory to the full backup directory. It rolls the data files in the full backup directory forward to the time of incremental backup and applies the redo logs as usual. Lastly, we apply the last incremental backup same as the previous one with just a small change. xtrabackup --prepare --target-dir=/mnt/data/backup/full --incremental-dir=/mnt/data/backup/incr1 We do not have to use the --apply-log-only option with it. It applies the incr2 delta files to the full backup data files taking them forward, applies redo logs on them and finally rollbacks the uncommitted transactions to produce the final result. The data now present in the full backup directory can now be used to restore. Note - To create cumulative incremental backups, the incremental-basedir should always be the full backup directory for every incremental backup. While preparing, we can start with the full backup with the --apply-log-only option and use just the last incremental backup for the final --prepare as that has all the changes since the full backup. Restoring Incremental backups Once all the above steps are completed, restoring is the same as done for a full backup.","title":"Percona Xtrabackup"},{"location":"level101/databases_sql/backup_recovery/#further-reading","text":"MySQL Point-In-Time-Recovery Another MySQL backup tool - mysqlpump Another MySQL backup tool - mydumper A comparison between mysqldump, mysqlpump and mydumper Backup Best Practices","title":"Further Reading"},{"location":"level101/databases_sql/concepts/","text":"Relational DBs are used for data storage. Even a file can be used to store data, but relational DBs are designed with specific goals: Efficiency Ease of access and management Organized Handle relations between data (represented as tables) Transaction: a unit of work that can comprise multiple statements, executed together ACID properties Set of properties that guarantee data integrity of DB transactions Atomicity: Each transaction is atomic (succeeds or fails completely) Consistency: Transactions only result in valid state (which includes rules, constraints, triggers etc.) Isolation: Each transaction is executed independently of others safely within a concurrent system Durability: Completed transactions will not be lost due to any later failures Let\u2019s take some examples to illustrate the above properties. Account A has a balance of \u20b9200 & B has \u20b9400. Account A is transferring \u20b9100 to Account B. This transaction has a deduction from sender and an addition into the recipient\u2019s balance. If the first operation passes successfully while the second fails, A\u2019s balance would be \u20b9100 while B would be having \u20b9400 instead of \u20b9500. Atomicity in a DB ensures this partially failed transaction is rolled back. If the second operation above fails, it leaves the DB inconsistent (sum of balance of accounts before and after the operation is not the same). Consistency ensures that this does not happen. There are three operations, one to calculate interest for A\u2019s account, another to add that to A\u2019s account, then transfer \u20b9100 from B to A. Without isolation guarantees, concurrent execution of these 3 operations may lead to a different outcome every time. What happens if the system crashes before the transactions are written to disk? Durability ensures that the changes are applied correctly during recovery. Relational data Tables represent relations Columns (fields) represent attributes Rows are individual records Schema describes the structure of DB SQL A query language to interact with and manage data. CRUD operations - create, read, update, delete queries Management operations - create DBs/tables/indexes etc, backup, import/export, users, access controls Exercise: Classify the below queries into the four types - DDL (definition), DML(manipulation), DCL(control) and TCL(transactions) and explain in detail. insert, create, drop, delete, update, commit, rollback, truncate, alter, grant, revoke You can practise these in the lab section . Constraints Rules for data that can be stored. Query fails if you violate any of these defined on a table. Primary key: one or more columns that contain UNIQUE values, and cannot contain NULL values. A table can have only ONE primary key. An index on it is created by default. Foreign key: links two tables together. Its value(s) match a primary key in a different table \\ Not null: Does not allow null values \\ Unique: Value of column must be unique across all rows \\ Default: Provides a default value for a column if none is specified during insert Check: Allows only particular values (like Balance >= 0) Indexes Most indexes use B+ tree structure. Why use them: Speeds up queries (in large tables that fetch only a few rows, min/max queries, by eliminating rows from consideration etc) Types of indexes: unique, primary key, fulltext, secondary Write-heavy loads, mostly full table scans or accessing large number of rows etc. do not benefit from indexes Joins Allows you to fetch related data from multiple tables, linking them together with some common field. Powerful but also resource-intensive and makes scaling databases difficult. This is the cause of many slow performing queries when run at scale, and the solution is almost always to find ways to reduce the joins. Access control DBs have privileged accounts for admin tasks, and regular accounts for clients. There are finegrained controls on what actions(DDL, DML etc. discussed earlier )are allowed for these accounts. DB first verifies the user credentials (authentication), and then examines whether this user is permitted to perform the request (authorization) by looking up these information in some internal tables. Other controls include activity auditing that allows examining the history of actions done by a user, and resource limits which define the number of queries, connections etc. allowed. Popular databases Commercial, closed source - Oracle, Microsoft SQL Server, IBM DB2 Open source with optional paid support - MySQL, MariaDB, PostgreSQL Individuals and small companies have always preferred open source DBs because of the huge cost associated with commercial software. In recent times, even large organizations have moved away from commercial software to open source alternatives because of the flexibility and cost savings associated with it. Lack of support is no longer a concern because of the paid support available from the developer and third parties. MySQL is the most widely used open source DB, and it is widely supported by hosting providers, making it easy for anyone to use. It is part of the popular Linux-Apache-MySQL-PHP ( LAMP ) stack that became popular in the 2000s. We have many more choices for a programming language, but the rest of that stack is still widely used.","title":"Key Concepts"},{"location":"level101/databases_sql/concepts/#popular-databases","text":"Commercial, closed source - Oracle, Microsoft SQL Server, IBM DB2 Open source with optional paid support - MySQL, MariaDB, PostgreSQL Individuals and small companies have always preferred open source DBs because of the huge cost associated with commercial software. In recent times, even large organizations have moved away from commercial software to open source alternatives because of the flexibility and cost savings associated with it. Lack of support is no longer a concern because of the paid support available from the developer and third parties. MySQL is the most widely used open source DB, and it is widely supported by hosting providers, making it easy for anyone to use. It is part of the popular Linux-Apache-MySQL-PHP ( LAMP ) stack that became popular in the 2000s. We have many more choices for a programming language, but the rest of that stack is still widely used.","title":"Popular databases"},{"location":"level101/databases_sql/conclusion/","text":"Conclusion We have covered basic concepts of SQL databases. We have also covered some of the tasks that an SRE may be responsible for - there is so much more to learn and do. We hope this course gives you a good start and inspires you to explore further. Further reading More practice with online resources like this one Normalization Routines , triggers Views Transaction isolation levels Sharding Setting up HA , monitoring , backups","title":"Conclusion"},{"location":"level101/databases_sql/conclusion/#conclusion","text":"We have covered basic concepts of SQL databases. We have also covered some of the tasks that an SRE may be responsible for - there is so much more to learn and do. We hope this course gives you a good start and inspires you to explore further.","title":"Conclusion"},{"location":"level101/databases_sql/conclusion/#further-reading","text":"More practice with online resources like this one Normalization Routines , triggers Views Transaction isolation levels Sharding Setting up HA , monitoring , backups","title":"Further reading"},{"location":"level101/databases_sql/innodb/","text":"Why should you use this? General purpose, row level locking, ACID support, transactions, crash recovery and multi-version concurrency control etc. Architecture Key components: Memory: Buffer pool: LRU cache of frequently used data(table and index) to be processed directly from memory, which speeds up processing. Important for tuning performance. Change buffer: Caches changes to secondary index pages when those pages are not in the buffer pool and merges it when they are fetched. Merging may take a long time and impact live queries. It also takes up part of the buffer pool. Avoids the extra I/O to read secondary indexes in. Adaptive hash index: Supplements InnoDB\u2019s B-Tree indexes with fast hash lookup tables like a cache. Slight performance penalty for misses, also adds maintenance overhead of updating it. Hash collisions cause AHI rebuilding for large DBs. Log buffer: Holds log data before flush to disk. Size of each above memory is configurable, and impacts performance a lot. Requires careful analysis of workload, available resources, benchmarking and tuning for optimal performance. Disk: Tables: Stores data within rows and columns. Indexes: Helps find rows with specific column values quickly, avoids full table scans. Redo Logs: all transactions are written to them, and after a crash, the recovery process corrects data written by incomplete transactions and replays any pending ones. Undo Logs: Records associated with a single transaction that contains information about how to undo the latest change by a transaction.","title":"InnoDB"},{"location":"level101/databases_sql/innodb/#why-should-you-use-this","text":"General purpose, row level locking, ACID support, transactions, crash recovery and multi-version concurrency control etc.","title":"Why should you use this?"},{"location":"level101/databases_sql/innodb/#architecture","text":"","title":"Architecture"},{"location":"level101/databases_sql/innodb/#key-components","text":"Memory: Buffer pool: LRU cache of frequently used data(table and index) to be processed directly from memory, which speeds up processing. Important for tuning performance. Change buffer: Caches changes to secondary index pages when those pages are not in the buffer pool and merges it when they are fetched. Merging may take a long time and impact live queries. It also takes up part of the buffer pool. Avoids the extra I/O to read secondary indexes in. Adaptive hash index: Supplements InnoDB\u2019s B-Tree indexes with fast hash lookup tables like a cache. Slight performance penalty for misses, also adds maintenance overhead of updating it. Hash collisions cause AHI rebuilding for large DBs. Log buffer: Holds log data before flush to disk. Size of each above memory is configurable, and impacts performance a lot. Requires careful analysis of workload, available resources, benchmarking and tuning for optimal performance. Disk: Tables: Stores data within rows and columns. Indexes: Helps find rows with specific column values quickly, avoids full table scans. Redo Logs: all transactions are written to them, and after a crash, the recovery process corrects data written by incomplete transactions and replays any pending ones. Undo Logs: Records associated with a single transaction that contains information about how to undo the latest change by a transaction.","title":"Key components:"},{"location":"level101/databases_sql/intro/","text":"Relational Databases Prerequisites Complete Linux course Install Docker (for lab section) What to expect from this course You will have an understanding of what relational databases are, their advantages, and some MySQL specific concepts. What is not covered under this course In depth implementation details Advanced topics like normalization, sharding Specific tools for administration Introduction The main purpose of database systems is to manage data. This includes storage, adding new data, deleting unused data, updating existing data, retrieving data within a reasonable response time, other maintenance tasks to keep the system running etc. Pre-reads RDBMS Concepts Course Contents Key Concepts MySQL Architecture InnoDB Backup and Recovery MySQL Replication Operational Concepts SELECT Query Query Performance Lab Further Reading","title":"Introduction"},{"location":"level101/databases_sql/intro/#relational-databases","text":"","title":"Relational Databases"},{"location":"level101/databases_sql/intro/#prerequisites","text":"Complete Linux course Install Docker (for lab section)","title":"Prerequisites"},{"location":"level101/databases_sql/intro/#what-to-expect-from-this-course","text":"You will have an understanding of what relational databases are, their advantages, and some MySQL specific concepts.","title":"What to expect from this course"},{"location":"level101/databases_sql/intro/#what-is-not-covered-under-this-course","text":"In depth implementation details Advanced topics like normalization, sharding Specific tools for administration","title":"What is not covered under this course"},{"location":"level101/databases_sql/intro/#introduction","text":"The main purpose of database systems is to manage data. This includes storage, adding new data, deleting unused data, updating existing data, retrieving data within a reasonable response time, other maintenance tasks to keep the system running etc.","title":"Introduction"},{"location":"level101/databases_sql/intro/#pre-reads","text":"RDBMS Concepts","title":"Pre-reads"},{"location":"level101/databases_sql/intro/#course-contents","text":"Key Concepts MySQL Architecture InnoDB Backup and Recovery MySQL Replication Operational Concepts SELECT Query Query Performance Lab Further Reading","title":"Course Contents"},{"location":"level101/databases_sql/lab/","text":"Prerequisites Install Docker Setup Create a working directory named sos or something similar, and cd into it. Enter the following into a file named my.cnf under a directory named custom. sos $ cat custom/my.cnf [mysqld] # These settings apply to MySQL server # You can set port, socket path, buffer size etc. # Below, we are configuring slow query settings slow_query_log=1 slow_query_log_file=/var/log/mysqlslow.log long_query_time=1 Start a container and enable slow query log with the following: sos $ docker run --name db -v custom:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=realsecret -d mysql:8 sos $ docker cp custom/my.cnf $(docker ps -qf \"name=db\"):/etc/mysql/conf.d/custom.cnf sos $ docker restart $(docker ps -qf \"name=db\") Import a sample database sos $ git clone git@github.com:datacharmer/test_db.git sos $ docker cp test_db $(docker ps -qf \"name=db\"):/home/test_db/ sos $ docker exec -it $(docker ps -qf \"name=db\") bash root@3ab5b18b0c7d:/# cd /home/test_db/ root@3ab5b18b0c7d:/# mysql -uroot -prealsecret mysql < employees.sql root@3ab5b18b0c7d:/etc# touch /var/log/mysqlslow.log root@3ab5b18b0c7d:/etc# chown mysql:mysql /var/log/mysqlslow.log Workshop 1: Run some sample queries Run the following $ mysql -uroot -prealsecret mysql mysql> # inspect DBs and tables # the last 4 are MySQL internal DBs mysql> show databases; +--------------------+ | Database | +--------------------+ | employees | | information_schema | | mysql | | performance_schema | | sys | +--------------------+ > use employees; mysql> show tables; +----------------------+ | Tables_in_employees | +----------------------+ | current_dept_emp | | departments | | dept_emp | | dept_emp_latest_date | | dept_manager | | employees | | salaries | | titles | +----------------------+ # read a few rows mysql> select * from employees limit 5; # filter data by conditions mysql> select count(*) from employees where gender = 'M' limit 5; # find count of particular data mysql> select count(*) from employees where first_name = 'Sachin'; Workshop 2: Use explain and explain analyze to profile a query, identify and add indexes required for improving performance # View all indexes on table #(\\G is to output horizontally, replace it with a ; to get table output) mysql> show index from employees from employees\\G *************************** 1. row *************************** Table: employees Non_unique: 0 Key_name: PRIMARY Seq_in_index: 1 Column_name: emp_no Collation: A Cardinality: 299113 Sub_part: NULL Packed: NULL Null: Index_type: BTREE Comment: Index_comment: Visible: YES Expression: NULL # This query uses an index, idenitfied by 'key' field # By prefixing explain keyword to the command, # we get query plan (including key used) mysql> explain select * from employees where emp_no < 10005\\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: employees partitions: NULL type: range possible_keys: PRIMARY key: PRIMARY key_len: 4 ref: NULL rows: 4 filtered: 100.00 Extra: Using where # Compare that to the next query which does not utilize any index mysql> explain select first_name, last_name from employees where first_name = 'Sachin'\\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: employees partitions: NULL type: ALL possible_keys: NULL key: NULL key_len: NULL ref: NULL rows: 299113 filtered: 10.00 Extra: Using where # Let's see how much time this query takes mysql> explain analyze select first_name, last_name from employees where first_name = 'Sachin'\\G *************************** 1. row *************************** EXPLAIN: -> Filter: (employees.first_name = 'Sachin') (cost=30143.55 rows=29911) (actual time=28.284..3952.428 rows=232 loops=1) -> Table scan on employees (cost=30143.55 rows=299113) (actual time=0.095..1996.092 rows=300024 loops=1) # Cost(estimated by query planner) is 30143.55 # actual time=28.284ms for first row, 3952.428 for all rows # Now lets try adding an index and running the query again mysql> create index idx_firstname on employees(first_name); Query OK, 0 rows affected (1.25 sec) Records: 0 Duplicates: 0 Warnings: 0 mysql> explain analyze select first_name, last_name from employees where first_name = 'Sachin'; +--------------------------------------------------------------------------------------------------------------------------------------------+ | EXPLAIN | +--------------------------------------------------------------------------------------------------------------------------------------------+ | -> Index lookup on employees using idx_firstname (first_name='Sachin') (cost=81.20 rows=232) (actual time=0.551..2.934 rows=232 loops=1) | +--------------------------------------------------------------------------------------------------------------------------------------------+ 1 row in set (0.01 sec) # Actual time=0.551ms for first row # 2.934ms for all rows. A huge improvement! # Also notice that the query involves only an index lookup, # and no table scan (reading all rows of table) # ..which vastly reduces load on the DB. Workshop 3: Identify slow queries on a MySQL server # Run the command below in two terminal tabs to open two shells into the container. docker exec -it $(docker ps -qf \"name=db\") bash # Open a mysql prompt in one of them and execute this command # We have configured to log queries that take longer than 1s, # so this sleep(3) will be logged mysql -uroot -prealsecret mysql mysql> select sleep(3); # Now, in the other terminal, tail the slow log to find details about the query root@62c92c89234d:/etc# tail -f /var/log/mysqlslow.log /usr/sbin/mysqld, Version: 8.0.21 (MySQL Community Server - GPL). started with: Tcp port: 3306 Unix socket: /var/run/mysqld/mysqld.sock Time Id Command Argument # Time: 2020-11-26T14:53:44.822348Z # User@Host: root[root] @ localhost [] Id: 9 # Query_time: 5.404938 Lock_time: 0.000000 Rows_sent: 1 Rows_examined: 1 use employees; # Time: 2020-11-26T14:53:58.015736Z # User@Host: root[root] @ localhost [] Id: 9 # Query_time: 10.000225 Lock_time: 0.000000 Rows_sent: 1 Rows_examined: 1 SET timestamp=1606402428; select sleep(3); These were simulated examples with minimal complexity. In real life, the queries would be much more complex and the explain/analyze and slow query logs would have more details.","title":"Lab"},{"location":"level101/databases_sql/mysql/","text":"MySQL architecture MySQL architecture enables you to select the right storage engine for your needs, and abstracts away all implementation details from the end users (application engineers and DBA ) who only need to know a consistent stable API. Application layer: Connection handling - each client gets its own connection which is cached for the duration of access) Authentication - server checks (username,password,host) info of client and allows/rejects connection Security: server determines whether the client has privileges to execute each query (check with show privileges command) Server layer: Services and utilities - backup/restore, replication, cluster etc SQL interface - clients run queries for data access and manipulation SQL parser - creates a parse tree from the query (lexical/syntactic/semantic analysis and code generation) Optimizer - optimizes queries using various algorithms and data available to it(table level stats), modifies queries, order of scanning, indexes to use etc. (check with explain command) Caches and buffers - cache stores query results, buffer pool(InnoDB) stores table and index data in LRU fashion Storage engine options: InnoDB: most widely used, transaction support, ACID compliant, supports row-level locking, crash recovery and multi-version concurrency control. Default since MySQL 5.5+. MyISAM: fast, does not support transactions, provides table-level locking, great for read-heavy workloads, mostly in web and data warehousing. Default upto MySQL 5.1. Archive: optimised for high speed inserts, compresses data as it is inserted, does not support transactions, ideal for storing and retrieving large amounts of seldom referenced historical, archived data Memory: tables in memory. Fastest engine, supports table-level locking, does not support transactions, ideal for creating temporary tables or quick lookups, data is lost after a shutdown CSV: stores data in CSV files, great for integrating into other applications that use this format \u2026 etc. It is possible to migrate from one storage engine to another. But this migration locks tables for all operations and is not online, as it changes the physical layout of the data. It takes a long time and is generally not recommended. Hence, choosing the right storage engine at the beginning is important. General guideline is to use InnoDB unless you have a specific need for one of the other storage engines. Running mysql> SHOW ENGINES; shows you the supported engines on your MySQL server.","title":"MySQL"},{"location":"level101/databases_sql/mysql/#mysql-architecture","text":"MySQL architecture enables you to select the right storage engine for your needs, and abstracts away all implementation details from the end users (application engineers and DBA ) who only need to know a consistent stable API. Application layer: Connection handling - each client gets its own connection which is cached for the duration of access) Authentication - server checks (username,password,host) info of client and allows/rejects connection Security: server determines whether the client has privileges to execute each query (check with show privileges command) Server layer: Services and utilities - backup/restore, replication, cluster etc SQL interface - clients run queries for data access and manipulation SQL parser - creates a parse tree from the query (lexical/syntactic/semantic analysis and code generation) Optimizer - optimizes queries using various algorithms and data available to it(table level stats), modifies queries, order of scanning, indexes to use etc. (check with explain command) Caches and buffers - cache stores query results, buffer pool(InnoDB) stores table and index data in LRU fashion Storage engine options: InnoDB: most widely used, transaction support, ACID compliant, supports row-level locking, crash recovery and multi-version concurrency control. Default since MySQL 5.5+. MyISAM: fast, does not support transactions, provides table-level locking, great for read-heavy workloads, mostly in web and data warehousing. Default upto MySQL 5.1. Archive: optimised for high speed inserts, compresses data as it is inserted, does not support transactions, ideal for storing and retrieving large amounts of seldom referenced historical, archived data Memory: tables in memory. Fastest engine, supports table-level locking, does not support transactions, ideal for creating temporary tables or quick lookups, data is lost after a shutdown CSV: stores data in CSV files, great for integrating into other applications that use this format \u2026 etc. It is possible to migrate from one storage engine to another. But this migration locks tables for all operations and is not online, as it changes the physical layout of the data. It takes a long time and is generally not recommended. Hence, choosing the right storage engine at the beginning is important. General guideline is to use InnoDB unless you have a specific need for one of the other storage engines. Running mysql> SHOW ENGINES; shows you the supported engines on your MySQL server.","title":"MySQL architecture"},{"location":"level101/databases_sql/operations/","text":"Explain and explain+analyze EXPLAIN analyzes query plans from the optimizer, including how tables are joined, which tables/rows are scanned etc. Explain analyze shows the above and additional info like execution cost, number of rows returned, time taken etc. This knowledge is useful to tweak queries and add indexes. Watch this performance tuning tutorial video . Checkout the lab section for a hands-on about indexes. Slow query logs Used to identify slow queries (configurable threshold), enabled in config or dynamically with a query Checkout the lab section about identifying slow queries. User management This includes creation and changes to users, like managing privileges, changing password etc. Backup and restore strategies, pros and cons Logical backup using mysqldump - slower but can be done online Physical backup (copy data directory or use xtrabackup) - quick backup/recovery. Copying data directory requires locking or shut down. xtrabackup is an improvement because it supports backups without shutting down (hot backup). Others - PITR, snapshots etc. Crash recovery process using redo logs After a crash, when you restart server it reads redo logs and replays modifications to recover Monitoring MySQL Key MySQL metrics: reads, writes, query runtime, errors, slow queries, connections, running threads, InnoDB metrics Key OS metrics: CPU, load, memory, disk I/O, network Replication Copies data from one instance to one or more instances. Helps in horizontal scaling, data protection, analytics and performance. Binlog dump thread on primary, replication I/O and SQL threads on secondary. Strategies include the standard async, semi async or group replication. High Availability Ability to cope with failure at software, hardware and network level. Essential for anyone who needs 99.9%+ uptime. Can be implemented with replication or clustering solutions from MySQL, Percona, Oracle etc. Requires expertise to setup and maintain. Failover can be manual, scripted or using tools like Orchestrator. Data directory Data is stored in a particular directory, with nested directories for the data contained in each database. There are also MySQL log files, InnoDB log files, server process ID file and some other configs. The data directory is configurable. MySQL configuration This can be done by passing parameters during startup , or in a file . There are a few standard paths where MySQL looks for config files, /etc/my.cnf is one of the commonly used paths. These options are organized under headers (mysqld for server and mysql for client), you can explore them more in the lab that follows. Logs MySQL has logs for various purposes - general query log, errors, binary logs (for replication), slow query log. Only error log is enabled by default (to reduce I/O and storage requirement), the others can be enabled when required - by specifying config parameters at startup or running commands at runtime. Log destination can also be tweaked with config parameters.","title":"Operations"},{"location":"level101/databases_sql/query_performance/","text":"Query Performance Improvement Query Performance is a very crucial aspect of relational databases. If not tuned correctly, the select queries can become slow and painful for the application, and for the MySQL server as well. The important task is to identify the slow queries and try to improve their performance by either rewriting them or creating proper indexes on the tables involved in it. The Slow Query Log The slow query log contains SQL statements that take a longer time to execute then set in the config parameter long_query_time. These queries are the candidates for optimization. There are some good utilities to summarize the slow query logs like, mysqldumpslow (provided by MySQL itself), pt-query-digest (provided by Percona), etc. Following are the config parameters that are used to enable and effectively catch slow queries Variable Explanation Example value slow_query_log Enables or disables slow query logs ON slow_query_log_file The location of the slow query log /var/lib/mysql/mysql-slow.log long_query_time Threshold time. The query that takes longer than this time is logged in slow query log 5 log_queries_not_using_indexes When enabled with the slow query log, the queries which do not make use of any index are also logged in the slow query log even though they take less time than long_query_time. ON So, for this section, we will be enabling slow_query_log , long_query_time will be kept to 0.3 (300 ms) , and log_queries_not_using index will be enabled as well. Below are the queries that we will execute on the employees database. select * from employees where last_name = 'Koblick'; select * from salaries where salary >= 100000; select * from titles where title = 'Manager'; select * from employees where year(hire_date) = 1995; select year(e.hire_date), max(s.salary) from employees e join salaries s on e.emp_no=s.emp_no group by year(e.hire_date); Now, queries 1 , 3 and 4 executed under 300 ms but if we check the slow query logs, we will find these queries logged as they are not using any of the index. Queries 2 and 5 are taking longer than 300ms and also not using any index. Use the following command to get the summary of the slow query log mysqldumpslow /var/lib/mysql/mysql-slow.log There are some more queries in the snapshot that were along with the queries mentioned. Mysqldumpslow replaces actual values that were used by N (in case of numbers) and S (in case of strings). That can be overridden by -a option, however that will increase the output lines if different values are used in similar queries. The EXPLAIN Plan The EXPLAIN command is used with any query that we want to analyze. It describes the query execution plan, how MySQL sees and executes the query. EXPLAIN works with Select, Insert, Update and Delete statements. It tells about different aspects of the query like, how tables are joined, indexes used or not, etc. The important thing here is to understand the basic Explain plan output of a query to determine its performance. Let's take the following query as an example, mysql> explain select * from salaries where salary = 100000; +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ | 1 | SIMPLE | salaries | NULL | ALL | NULL | NULL | NULL | NULL | 2838426 | 10.00 | Using where | +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) The key aspects to understand in the above output are:- Partitions - the number of partitions considered while executing the query. It is only valid if the table is partitioned. Possible_keys - the list of indexes that were considered during creation of the execution plan. Key - the index that will be used while executing the query. Rows - the number of rows examined during the execution. Filtered - the percentage of rows that were filtered out of the rows examined. The maximum and most optimized result will have 100 in this field. Extra - this tells some extra information on how MySQL evaluates, whether the query is using only where clause to match target rows, any index or temporary table, etc. So, for the above query, we can determine that there are no partitions, there are no candidate indexes to be used and so no index is used at all, over 2M rows are examined and only 10% of them are included in the result, and lastly, only a where clause is used to match the target rows. Creating an Index Indexes are used to speed up selecting relevant rows for a given column value. Without an index, MySQL starts with the first row and goes through the entire table to find matching rows. If the table has too many rows, the operation becomes costly. With indexes, MySQL determines the position to start looking for the data without reading the full table. A primary key is also an index which is also the fastest and is stored along with the table data. Secondary indexes are stored outside of the table data and are used to further enhance the performance of SQL statements. Indexes are mostly stored as B-Trees, with some exceptions like spatial indexes use R-Trees and memory tables use hash indexes. There are 2 ways to create indexes:- While creating a table - if we know beforehand the columns that will drive the most number of where clauses in select queries, then we can put an index over them while creating a table. Altering a Table - To improve the performance of a troubling query, we create an index on a table which already has data in it using ALTER or CREATE INDEX command. This operation does not block the table but might take some time to complete depending on the size of the table. Let\u2019s look at the query that we discussed in the previous section. It\u2019s clear that scanning over 2M records is not a good idea when only 10% of those records are actually in the resultset. Hence, we create an index on the salary column of the salaries table. create index idx_salary on salaries(salary) OR alter table salaries add index idx_salary(salary) And the same explain plan now looks like this mysql> explain select * from salaries where salary = 100000; +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ | 1 | SIMPLE | salaries | NULL | ref | idx_salary | idx_salary | 4 | const | 13 | 100.00 | NULL | +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) Now the index used is idx_salary, the one we recently created. The index actually helped examine only 13 records and all of them are in the resultset. Also, the query execution time is also reduced from over 700ms to almost negligible. Let\u2019s look at another example. Here we are searching for a specific combination of first_name and last_name. But, we might also search based on last_name only. mysql> explain select * from employees where last_name = 'Dredge' and first_name = 'Yinghua'; +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | 1 | SIMPLE | employees | NULL | ALL | NULL | NULL | NULL | NULL | 299468 | 1.00 | Using where | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) Now only 1% record out of almost 300K is the resultset. Although the query time is particularly quick as we have only 300K records, this will be a pain if the number of records are over millions. In this case, we create an index on last_name and first_name, not separately, but a composite index including both the columns. create index idx_last_first on employees(last_name, first_name) mysql> explain select * from employees where last_name = 'Dredge' and first_name = 'Yinghua'; +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ | 1 | SIMPLE | employees | NULL | ref | idx_last_first | idx_last_first | 124 | const,const | 1 | 100.00 | NULL | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) We chose to put last_name before first_name while creating the index as the optimizer starts from the leftmost prefix of the index while evaluating the query. For example, if we have a 3-column index like idx(c1, c2, c3), then the search capability of the index follows - (c1), (c1, c2) or (c1, c2, c3) i.e. if your where clause has only first_name this index won\u2019t work. mysql> explain select * from employees where first_name = 'Yinghua'; +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | 1 | SIMPLE | employees | NULL | ALL | NULL | NULL | NULL | NULL | 299468 | 10.00 | Using where | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) But, if you have only the last_name in the where clause, it will work as expected. mysql> explain select * from employees where last_name = 'Dredge'; +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ | 1 | SIMPLE | employees | NULL | ref | idx_last_first | idx_last_first | 66 | const | 200 | 100.00 | NULL | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) For another example, use the following queries:- create table employees_2 like employees; create table salaries_2 like salaries; alter table salaries_2 drop primary key; We made copies of employees and salaries tables without the Primary Key of salaries table to understand an example of Select with Join. When you have queries like the below, it becomes tricky to identify the pain point of the query. mysql> select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; 1860 rows in set (4.44 sec) This query is taking about 4.5 seconds to complete with 1860 rows in the resultset. Let\u2019s look at the Explain plan. There will be 2 records in the Explain plan as 2 tables are used in the query. mysql> explain select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ | 1 | SIMPLE | s | NULL | ALL | NULL | NULL | NULL | NULL | 2837194 | 100.00 | NULL | | 1 | SIMPLE | e | NULL | eq_ref | PRIMARY,idx_last_first | PRIMARY | 4 | employees.s.emp_no | 1 | 5.00 | Using where | +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ 2 rows in set, 1 warning (0.00 sec) These are in order of evaluation i.e. salaries_2 will be evaluated first and then employees_2 will be joined to it. As it looks like, it scans almost all the rows of salaries_2 table and tries to match the employees_2 rows as per the join condition. Though where clause is used in fetching the final resultset, but the index corresponding to the where clause is not used for the employees_2 table. If the join is done on two indexes which have the same data-types, it will always be faster. So, let\u2019s create an index on the emp_no column of salaries_2 table and analyze the query again. create index idx_empno on salaries_2(emp_no); mysql> explain select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ | 1 | SIMPLE | e | NULL | ref | PRIMARY,idx_last_first | idx_last_first | 66 | const | 200 | 100.00 | NULL | | 1 | SIMPLE | s | NULL | ref | idx_empno | idx_empno | 4 | employees.e.emp_no | 9 | 100.00 | NULL | +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ 2 rows in set, 1 warning (0.00 sec) Now, not only did the index help the optimizer to examine only a few rows in both tables, it reversed the order of the tables in evaluation. The employees_2 table is evaluated first and rows are selected as per the index respective to the where clause. Then the records are joined to salaries_2 table as per the index used due to the join condition. The execution time of the query came down from 4.5s to 0.02s . mysql> select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'\\G 1860 rows in set (0.02 sec)","title":"Query Performance"},{"location":"level101/databases_sql/query_performance/#query-performance-improvement","text":"Query Performance is a very crucial aspect of relational databases. If not tuned correctly, the select queries can become slow and painful for the application, and for the MySQL server as well. The important task is to identify the slow queries and try to improve their performance by either rewriting them or creating proper indexes on the tables involved in it.","title":"Query Performance Improvement"},{"location":"level101/databases_sql/query_performance/#the-slow-query-log","text":"The slow query log contains SQL statements that take a longer time to execute then set in the config parameter long_query_time. These queries are the candidates for optimization. There are some good utilities to summarize the slow query logs like, mysqldumpslow (provided by MySQL itself), pt-query-digest (provided by Percona), etc. Following are the config parameters that are used to enable and effectively catch slow queries Variable Explanation Example value slow_query_log Enables or disables slow query logs ON slow_query_log_file The location of the slow query log /var/lib/mysql/mysql-slow.log long_query_time Threshold time. The query that takes longer than this time is logged in slow query log 5 log_queries_not_using_indexes When enabled with the slow query log, the queries which do not make use of any index are also logged in the slow query log even though they take less time than long_query_time. ON So, for this section, we will be enabling slow_query_log , long_query_time will be kept to 0.3 (300 ms) , and log_queries_not_using index will be enabled as well. Below are the queries that we will execute on the employees database. select * from employees where last_name = 'Koblick'; select * from salaries where salary >= 100000; select * from titles where title = 'Manager'; select * from employees where year(hire_date) = 1995; select year(e.hire_date), max(s.salary) from employees e join salaries s on e.emp_no=s.emp_no group by year(e.hire_date); Now, queries 1 , 3 and 4 executed under 300 ms but if we check the slow query logs, we will find these queries logged as they are not using any of the index. Queries 2 and 5 are taking longer than 300ms and also not using any index. Use the following command to get the summary of the slow query log mysqldumpslow /var/lib/mysql/mysql-slow.log There are some more queries in the snapshot that were along with the queries mentioned. Mysqldumpslow replaces actual values that were used by N (in case of numbers) and S (in case of strings). That can be overridden by -a option, however that will increase the output lines if different values are used in similar queries.","title":"The Slow Query Log"},{"location":"level101/databases_sql/query_performance/#the-explain-plan","text":"The EXPLAIN command is used with any query that we want to analyze. It describes the query execution plan, how MySQL sees and executes the query. EXPLAIN works with Select, Insert, Update and Delete statements. It tells about different aspects of the query like, how tables are joined, indexes used or not, etc. The important thing here is to understand the basic Explain plan output of a query to determine its performance. Let's take the following query as an example, mysql> explain select * from salaries where salary = 100000; +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ | 1 | SIMPLE | salaries | NULL | ALL | NULL | NULL | NULL | NULL | 2838426 | 10.00 | Using where | +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) The key aspects to understand in the above output are:- Partitions - the number of partitions considered while executing the query. It is only valid if the table is partitioned. Possible_keys - the list of indexes that were considered during creation of the execution plan. Key - the index that will be used while executing the query. Rows - the number of rows examined during the execution. Filtered - the percentage of rows that were filtered out of the rows examined. The maximum and most optimized result will have 100 in this field. Extra - this tells some extra information on how MySQL evaluates, whether the query is using only where clause to match target rows, any index or temporary table, etc. So, for the above query, we can determine that there are no partitions, there are no candidate indexes to be used and so no index is used at all, over 2M rows are examined and only 10% of them are included in the result, and lastly, only a where clause is used to match the target rows.","title":"The EXPLAIN Plan"},{"location":"level101/databases_sql/query_performance/#creating-an-index","text":"Indexes are used to speed up selecting relevant rows for a given column value. Without an index, MySQL starts with the first row and goes through the entire table to find matching rows. If the table has too many rows, the operation becomes costly. With indexes, MySQL determines the position to start looking for the data without reading the full table. A primary key is also an index which is also the fastest and is stored along with the table data. Secondary indexes are stored outside of the table data and are used to further enhance the performance of SQL statements. Indexes are mostly stored as B-Trees, with some exceptions like spatial indexes use R-Trees and memory tables use hash indexes. There are 2 ways to create indexes:- While creating a table - if we know beforehand the columns that will drive the most number of where clauses in select queries, then we can put an index over them while creating a table. Altering a Table - To improve the performance of a troubling query, we create an index on a table which already has data in it using ALTER or CREATE INDEX command. This operation does not block the table but might take some time to complete depending on the size of the table. Let\u2019s look at the query that we discussed in the previous section. It\u2019s clear that scanning over 2M records is not a good idea when only 10% of those records are actually in the resultset. Hence, we create an index on the salary column of the salaries table. create index idx_salary on salaries(salary) OR alter table salaries add index idx_salary(salary) And the same explain plan now looks like this mysql> explain select * from salaries where salary = 100000; +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ | 1 | SIMPLE | salaries | NULL | ref | idx_salary | idx_salary | 4 | const | 13 | 100.00 | NULL | +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) Now the index used is idx_salary, the one we recently created. The index actually helped examine only 13 records and all of them are in the resultset. Also, the query execution time is also reduced from over 700ms to almost negligible. Let\u2019s look at another example. Here we are searching for a specific combination of first_name and last_name. But, we might also search based on last_name only. mysql> explain select * from employees where last_name = 'Dredge' and first_name = 'Yinghua'; +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | 1 | SIMPLE | employees | NULL | ALL | NULL | NULL | NULL | NULL | 299468 | 1.00 | Using where | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) Now only 1% record out of almost 300K is the resultset. Although the query time is particularly quick as we have only 300K records, this will be a pain if the number of records are over millions. In this case, we create an index on last_name and first_name, not separately, but a composite index including both the columns. create index idx_last_first on employees(last_name, first_name) mysql> explain select * from employees where last_name = 'Dredge' and first_name = 'Yinghua'; +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ | 1 | SIMPLE | employees | NULL | ref | idx_last_first | idx_last_first | 124 | const,const | 1 | 100.00 | NULL | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) We chose to put last_name before first_name while creating the index as the optimizer starts from the leftmost prefix of the index while evaluating the query. For example, if we have a 3-column index like idx(c1, c2, c3), then the search capability of the index follows - (c1), (c1, c2) or (c1, c2, c3) i.e. if your where clause has only first_name this index won\u2019t work. mysql> explain select * from employees where first_name = 'Yinghua'; +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | 1 | SIMPLE | employees | NULL | ALL | NULL | NULL | NULL | NULL | 299468 | 10.00 | Using where | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) But, if you have only the last_name in the where clause, it will work as expected. mysql> explain select * from employees where last_name = 'Dredge'; +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ | 1 | SIMPLE | employees | NULL | ref | idx_last_first | idx_last_first | 66 | const | 200 | 100.00 | NULL | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) For another example, use the following queries:- create table employees_2 like employees; create table salaries_2 like salaries; alter table salaries_2 drop primary key; We made copies of employees and salaries tables without the Primary Key of salaries table to understand an example of Select with Join. When you have queries like the below, it becomes tricky to identify the pain point of the query. mysql> select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; 1860 rows in set (4.44 sec) This query is taking about 4.5 seconds to complete with 1860 rows in the resultset. Let\u2019s look at the Explain plan. There will be 2 records in the Explain plan as 2 tables are used in the query. mysql> explain select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ | 1 | SIMPLE | s | NULL | ALL | NULL | NULL | NULL | NULL | 2837194 | 100.00 | NULL | | 1 | SIMPLE | e | NULL | eq_ref | PRIMARY,idx_last_first | PRIMARY | 4 | employees.s.emp_no | 1 | 5.00 | Using where | +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ 2 rows in set, 1 warning (0.00 sec) These are in order of evaluation i.e. salaries_2 will be evaluated first and then employees_2 will be joined to it. As it looks like, it scans almost all the rows of salaries_2 table and tries to match the employees_2 rows as per the join condition. Though where clause is used in fetching the final resultset, but the index corresponding to the where clause is not used for the employees_2 table. If the join is done on two indexes which have the same data-types, it will always be faster. So, let\u2019s create an index on the emp_no column of salaries_2 table and analyze the query again. create index idx_empno on salaries_2(emp_no); mysql> explain select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ | 1 | SIMPLE | e | NULL | ref | PRIMARY,idx_last_first | idx_last_first | 66 | const | 200 | 100.00 | NULL | | 1 | SIMPLE | s | NULL | ref | idx_empno | idx_empno | 4 | employees.e.emp_no | 9 | 100.00 | NULL | +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ 2 rows in set, 1 warning (0.00 sec) Now, not only did the index help the optimizer to examine only a few rows in both tables, it reversed the order of the tables in evaluation. The employees_2 table is evaluated first and rows are selected as per the index respective to the where clause. Then the records are joined to salaries_2 table as per the index used due to the join condition. The execution time of the query came down from 4.5s to 0.02s . mysql> select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'\\G 1860 rows in set (0.02 sec)","title":"Creating an Index"},{"location":"level101/databases_sql/replication/","text":"MySQL Replication Replication enables data from one MySQL host (termed as Primary) to be copied to another MySQL host (termed as Replica). MySQL Replication is asynchronous in nature by default, but it can be changed to semi-synchronous with some configurations. Some common applications of MySQL replication are:- Read-scaling - as multiple hosts can replicate the data from a single primary host, we can set up as many replicas as we need and scale reads through them, i.e. application writes will go to a single primary host and the reads can balance between all the replicas that are there. Such a setup can improve the write performance as well, as the primary is dedicated to only updates and not reads. Backups using replicas - the backup process can sometimes be a little heavy. But if we have replicas configured, then we can use one of them to get the backup without affecting the primary data at all. Disaster Recovery - a replica in some other geographical region paves a proper path to configure disaster recovery. MySQL supports different types of synchronizations as well:- Asynchronous - this is the default synchronization method. It is one-way, i.e. one host serves as primary and one or more hosts as replica. We will discuss this method throughout the replication topic. Semi-Synchronous - in this type of synchronization, a commit performed on the primary host is blocked until at least one replica acknowledges it. Post the acknowledgement from any one replica, the control is returned to the session that performed the transaction. This ensures strong consistency but the replication is slower than asynchronous. Delayed - we can deliberately lag the replica in a typical MySQL replication by the number of seconds desired by the use case. This type of replication safeguards from severe human errors of dropping or corrupting the data on the primary, for example, in the above diagram for Delayed Replication, if a DROP DATABASE is executed by mistake on the primary, we still have 30 minutes to recover the data from R2 as that command has not been replicated on R2 yet. Pre-Requisites Before we dive into setting up replication, we should know about the binary logs. Binary logs play a very important role in MySQL replication. Binary logs, or commonly known as binlogs contain events about the changes done to the database, like table structure changes, data changes via DML operations, etc. They are not used to log SELECT statements. For replication, the primary sends the information to the replicas using its binlogs about the changes done to the database, and the replicas make the same data changes. With respect to MySQL replication, the binary log format can be of two types that decides the main type of replication:- - Statement-Based Replication or SBR - Row-Based Replication or RBR Statement Based Binlog Format Originally, the replication in MySQL was based on SQL statements getting replicated and executed on the replica from the primary. This is called statement based logging. The binlog contains the exact SQL statement run by the session. So If we run the above statements to insert 3 records and the update 3 in a single update statement, they will be logged exactly the same as when we executed them. Row Based Binlog Format The Row based is the default one in the latest MySQL releases. This is a lot different from the Statement format as here, row events are logged instead of statements. By that we mean, in the above example one update statement affected 3 records, but binlog had only one update statement; if it is a row based format, binlog will have an event for each record updated. Statement Based v/s Row Based binlogs Let\u2019s have a look at the operational differences between statement-based and row-based binlogs. Statement Based Row Based Logs SQL statements as executed Logs row events based on SQL statements executed Takes lesser disk space Takes more disk space Restoring using binlogs is faster Restoring using binlogs is slower When used for replication, if any statement has a predefined function that has its own value, like sysdate(), uuid() etc, the output could be different on the replica which makes it inconsistent. Whatever is executed becomes a row event with values, so there will be no problem if such functions are used in SQL statements. Only statements are logged so no other row events are generated. A lot of events are generated when a table is copied into another using INSERT INTO SELECT. Note - There is another type of binlog format called Mixed . With mixed logging, statement based is used by default but it switches to row based in certain cases. If MySQL cannot guarantee that statement based logging is safe for the statements executed, it issues a warning and switches to row based for those statements. We will be using binary log format as Row for the entire replication topic. Replication in Motion The above figure indicates how a typical MySQL replication works. Replica_IO_Thread is responsible to fetch the binlog events from the primary binary logs to the replica On the Replica host, relay logs are created which are exact copies of the binary logs. If the binary logs on primary are in row format, the relay logs will be the same. Replica_SQL_Thread applies the relay logs on the replica MySQL server. If log-bin is enabled on the replica, then the replica will have its own binary logs as well. If log-slave-updates is enabled, then it will have the updates from the primary logged in the binlogs as well. Setting up Replication In this section, we will set up a simple asynchronous replication. The binlogs will be in row based format. The replication will be set up on two fresh hosts with no prior data present. There are two different ways in which we can set up replication. Binlog based - Each replica keeps a record of the binlog coordinates on the primary - current binlog and position in the binlog till where it has read and processed. So, at a time different replicas might be reading different parts of the same binlog. GTID based - Every transaction gets an identifier called global transaction identifier or GTID. There is no need to keep the record of binlog coordinates, as long as the replica has all the GTIDs executed on the primary, it is consistent with the primary. A typical GTID is the server_uuid:# positive integer. We will set up a GTID based replication in the following section but will also discuss binlog based replication setup as well. Primary Host Configurations The following config parameters should be present in the primary my.cnf file for setting up GTID based replication. server-id - a unique ID for the mysql server log-bin - the binlog location binlog-format - ROW | STATEMENT (we will use ROW) gtid-mode - ON enforce-gtid-consistency - ON (allows execution of only those statements which can be logged using GTIDs) Replica Host Configurations The following config parameters should be present in the replica my.cnf file for setting up replication. server-id - different than the primary host log-bin - (optional, if you want replica to log its own changes as well) binlog-format - depends on the above gtid-mode - ON enforce-gtid-consistency - ON log-slave-updates - ON (if binlog is enabled, then we can enable this. This enables the replica to log the changes coming from the primary along with its own changes. Helps in setting up chain replication) Replication User Every replica connects to the primary using a mysql user for replicating. So there must be a mysql user account for the same on the primary host. Any user can be used for this purpose provided it has REPLICATION SLAVE privilege. If the sole purpose is replication then we can have a user with only the required privilege. On the primary host mysql> create user repl_user@ identified by 'xxxxx'; mysql> grant replication slave on *.* to repl_user@''; Obtaining Starting position from Primary Run the following command on the primary host mysql> show master status\\G *************************** 1. row *************************** File: mysql-bin.000001 Position: 73 Binlog_Do_DB: Binlog_Ignore_DB: Executed_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 1 row in set (0.00 sec) If we are working with binary log based replication, the top two output lines are the most important ones. That tells the current binlog on the primary host and till what position it has written. For fresh hosts we know that no data is written so we can directly set up replication using the very first binlog file and position 4. If we are setting up a replication from a backup, then that changes the way we obtain the starting position. For GTIDs, the executed_gtid_set is the value where primary is right now. Again, for a fresh setup, we don\u2019t have to specify anything about the starting point and it will start from the transaction id 1, but when we set up from a backup, the backup will contain the GTID positions till where backup has been taken. Setting up Replica The replication setup must know about the primary host, the user and password to connect, the binlog coordinates (for binlog based replication) or the GTID auto-position parameter. The following command is used for setting up change master to master_host = '', master_port = , master_user = 'repl_user', master_password = 'xxxxx', master_auto_position = 1; Note - the Change Master To command has been replaced with Change Replication Source To from Mysql 8.0.23 onwards, also all the master and slave keywords are replaced with source and replica . If it is binlog based replication, then instead of master_auto_position, we need to specify the binlog coordinates. master_log_file = 'mysql-bin.000001', master_log_pos = 4 Starting Replication and Check Status Now that everything is configured, we just need to start the replication on the replica via the following command start slave; OR from MySQL 8.0.23 onwards, start replica; Whether or not the replication is running successfully, we can determine by running the following command show slave status\\G OR from MySQL 8.0.23 onwards, show replica status\\G mysql> show replica status\\G *************************** 1. row *************************** Replica_IO_State: Waiting for master to send event Source_Host: Source_User: repl_user Source_Port: Connect_Retry: 60 Source_Log_File: mysql-bin.000001 Read_Source_Log_Pos: 852 Relay_Log_File: mysql-relay-bin.000002 Relay_Log_Pos: 1067 Relay_Source_Log_File: mysql-bin.000001 Replica_IO_Running: Yes Replica_SQL_Running: Yes Replicate_Do_DB: Replicate_Ignore_DB: Replicate_Do_Table: Replicate_Ignore_Table: Replicate_Wild_Do_Table: Replicate_Wild_Ignore_Table: Last_Errno: 0 Last_Error: Skip_Counter: 0 Exec_Source_Log_Pos: 852 Relay_Log_Space: 1283 Until_Condition: None Until_Log_File: Until_Log_Pos: 0 Source_SSL_Allowed: No Source_SSL_CA_File: Source_SSL_CA_Path: Source_SSL_Cert: Source_SSL_Cipher: Source_SSL_Key: Seconds_Behind_Source: 0 Source_SSL_Verify_Server_Cert: No Last_IO_Errno: 0 Last_IO_Error: Last_SQL_Errno: 0 Last_SQL_Error: Replicate_Ignore_Server_Ids: Source_Server_Id: 1 Source_UUID: e17d0920-d00e-11eb-a3e6-000d3aa00f87 Source_Info_File: mysql.slave_master_info SQL_Delay: 0 SQL_Remaining_Delay: NULL Replica_SQL_Running_State: Slave has read all relay log; waiting for more updates Source_Retry_Count: 86400 Source_Bind: Last_IO_Error_Timestamp: Last_SQL_Error_Timestamp: Source_SSL_Crl: Source_SSL_Crlpath: Retrieved_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 Executed_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 Auto_Position: 1 Replicate_Rewrite_DB: Channel_Name: Source_TLS_Version: Source_public_key_path: Get_Source_public_key: 0 Network_Namespace: 1 row in set (0.00 sec) Some of the parameters are explained below:- Relay_Source_Log_File - the primary\u2019s file where replica is currently reading from Execute_Source_Log_Pos - for the above file on which position is the replica reading currently from. These two parameters are of utmost importance when binlog based replication is used. Replica_IO_Running - IO thread of replica is running or not Replica_SQL_Running - SQL thread of replica is running or not Seconds_Behind_Source - the difference of seconds when a statement was executed on Primary and then on Replica. This indicates how much replication lag is there. Source_UUID - the uuid of the primary host Retrieved_Gtid_Set - the GTIDs fetched from the primary host by the replica to be executed. Executed_Gtid_Set - the GTIDs executed on the replica. This set remains the same for the entire cluster if the replicas are in sync. Auto_Position - it directs the replica to fetch the next GTID automatically Create a Replica for the already setup cluster The steps discussed in the previous section talks about the setting up replication on two fresh hosts. When we have to set up a replica for a host which is already serving applications, then the backup of the primary is used, either fresh backup taken for the replica (should only be done if the traffic it is serving is less) or use a recently taken backup. If the size of the databases on the MySQL primary server is small, less than 100G recommended, then mysqldump can be used to take backup along with the following options. mysqldump -uroot -p -hhost_ip -P3306 --all-databases --single-transaction --master-data=1 > primary_host.bkp --single-transaction - this option starts a transaction before taking the backup which ensures it is consistent. As transactions are isolated from each other, so no other writes affect the backup. --master-data - this option is required if binlog based replication is desired to be set up. It includes the binary log file and log file position in the backup file. When GTID mode is enabled and mysqldump is executed, it includes the GTID executed to be used to start the replica after the backup position. The contents of the mysqldump output file will have the following It is recommended to comment these before restoring otherwise they could throw errors. Also, using master-data=2 will automatically comment the master_log_file line. Similarly, when taking backup of the host using xtrabackup , the file xtrabckup_info file contains the information about binlog file and file position, as well as the GTID executed set. server_version = 8.0.25 start_time = 2021-06-22 03:45:17 end_time = 2021-06-22 03:45:20 lock_time = 0 binlog_pos = filename 'mysql-bin.000007', position '196', GTID of the last change 'e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-5' innodb_from_lsn = 0 innodb_to_lsn = 18153149 partial = N incremental = N format = file compressed = N encrypted = N Now, after setting MySQL server on the desired host, restore the backup taken from any one of the above methods. If the intended way is binlog based replication, then use the binlog file and position info in the following command change Replication Source to source_host = \u2018primary_ip\u2019, source_port = 3306, source_user = \u2018repl_user\u2019, source_password = \u2018xxxxx\u2019, source_log_file = \u2018mysql-bin.000007\u2019, source_log_pos = \u2018196\u2019; If the replication needs to be set via GITDs, then run the below command to tell the replica about the GTIDs already executed. On the Replica host, run th following commands reset master; set global gtid_purged = \u2018e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-5\u2019 change replication source to source_host = \u2018primary_ip\u2019, source_port = 3306, source_user = \u2018repl_user\u2019, source_password = \u2018xxxxx\u2019, source_auto_position = 1 The reset master command resets the position of the binary log to initial. It can be skipped if the host is a freshly installed MySQL, but we restored a backup so it is necessary. The gtid_purged global variable lets the replica know the GTIDs that have already been executed, so that the replication can start after that. Then in the change source command, we set the auto-position to 1 which automatically gets the next GTID to proceed. Further Reading More applications of Replication Automtaed Failovers using MySQL Orchestrator","title":"MySQL Replication"},{"location":"level101/databases_sql/replication/#mysql-replication","text":"Replication enables data from one MySQL host (termed as Primary) to be copied to another MySQL host (termed as Replica). MySQL Replication is asynchronous in nature by default, but it can be changed to semi-synchronous with some configurations. Some common applications of MySQL replication are:- Read-scaling - as multiple hosts can replicate the data from a single primary host, we can set up as many replicas as we need and scale reads through them, i.e. application writes will go to a single primary host and the reads can balance between all the replicas that are there. Such a setup can improve the write performance as well, as the primary is dedicated to only updates and not reads. Backups using replicas - the backup process can sometimes be a little heavy. But if we have replicas configured, then we can use one of them to get the backup without affecting the primary data at all. Disaster Recovery - a replica in some other geographical region paves a proper path to configure disaster recovery. MySQL supports different types of synchronizations as well:- Asynchronous - this is the default synchronization method. It is one-way, i.e. one host serves as primary and one or more hosts as replica. We will discuss this method throughout the replication topic. Semi-Synchronous - in this type of synchronization, a commit performed on the primary host is blocked until at least one replica acknowledges it. Post the acknowledgement from any one replica, the control is returned to the session that performed the transaction. This ensures strong consistency but the replication is slower than asynchronous. Delayed - we can deliberately lag the replica in a typical MySQL replication by the number of seconds desired by the use case. This type of replication safeguards from severe human errors of dropping or corrupting the data on the primary, for example, in the above diagram for Delayed Replication, if a DROP DATABASE is executed by mistake on the primary, we still have 30 minutes to recover the data from R2 as that command has not been replicated on R2 yet. Pre-Requisites Before we dive into setting up replication, we should know about the binary logs. Binary logs play a very important role in MySQL replication. Binary logs, or commonly known as binlogs contain events about the changes done to the database, like table structure changes, data changes via DML operations, etc. They are not used to log SELECT statements. For replication, the primary sends the information to the replicas using its binlogs about the changes done to the database, and the replicas make the same data changes. With respect to MySQL replication, the binary log format can be of two types that decides the main type of replication:- - Statement-Based Replication or SBR - Row-Based Replication or RBR Statement Based Binlog Format Originally, the replication in MySQL was based on SQL statements getting replicated and executed on the replica from the primary. This is called statement based logging. The binlog contains the exact SQL statement run by the session. So If we run the above statements to insert 3 records and the update 3 in a single update statement, they will be logged exactly the same as when we executed them. Row Based Binlog Format The Row based is the default one in the latest MySQL releases. This is a lot different from the Statement format as here, row events are logged instead of statements. By that we mean, in the above example one update statement affected 3 records, but binlog had only one update statement; if it is a row based format, binlog will have an event for each record updated. Statement Based v/s Row Based binlogs Let\u2019s have a look at the operational differences between statement-based and row-based binlogs. Statement Based Row Based Logs SQL statements as executed Logs row events based on SQL statements executed Takes lesser disk space Takes more disk space Restoring using binlogs is faster Restoring using binlogs is slower When used for replication, if any statement has a predefined function that has its own value, like sysdate(), uuid() etc, the output could be different on the replica which makes it inconsistent. Whatever is executed becomes a row event with values, so there will be no problem if such functions are used in SQL statements. Only statements are logged so no other row events are generated. A lot of events are generated when a table is copied into another using INSERT INTO SELECT. Note - There is another type of binlog format called Mixed . With mixed logging, statement based is used by default but it switches to row based in certain cases. If MySQL cannot guarantee that statement based logging is safe for the statements executed, it issues a warning and switches to row based for those statements. We will be using binary log format as Row for the entire replication topic. Replication in Motion The above figure indicates how a typical MySQL replication works. Replica_IO_Thread is responsible to fetch the binlog events from the primary binary logs to the replica On the Replica host, relay logs are created which are exact copies of the binary logs. If the binary logs on primary are in row format, the relay logs will be the same. Replica_SQL_Thread applies the relay logs on the replica MySQL server. If log-bin is enabled on the replica, then the replica will have its own binary logs as well. If log-slave-updates is enabled, then it will have the updates from the primary logged in the binlogs as well.","title":"MySQL Replication"},{"location":"level101/databases_sql/replication/#setting-up-replication","text":"In this section, we will set up a simple asynchronous replication. The binlogs will be in row based format. The replication will be set up on two fresh hosts with no prior data present. There are two different ways in which we can set up replication. Binlog based - Each replica keeps a record of the binlog coordinates on the primary - current binlog and position in the binlog till where it has read and processed. So, at a time different replicas might be reading different parts of the same binlog. GTID based - Every transaction gets an identifier called global transaction identifier or GTID. There is no need to keep the record of binlog coordinates, as long as the replica has all the GTIDs executed on the primary, it is consistent with the primary. A typical GTID is the server_uuid:# positive integer. We will set up a GTID based replication in the following section but will also discuss binlog based replication setup as well. Primary Host Configurations The following config parameters should be present in the primary my.cnf file for setting up GTID based replication. server-id - a unique ID for the mysql server log-bin - the binlog location binlog-format - ROW | STATEMENT (we will use ROW) gtid-mode - ON enforce-gtid-consistency - ON (allows execution of only those statements which can be logged using GTIDs) Replica Host Configurations The following config parameters should be present in the replica my.cnf file for setting up replication. server-id - different than the primary host log-bin - (optional, if you want replica to log its own changes as well) binlog-format - depends on the above gtid-mode - ON enforce-gtid-consistency - ON log-slave-updates - ON (if binlog is enabled, then we can enable this. This enables the replica to log the changes coming from the primary along with its own changes. Helps in setting up chain replication) Replication User Every replica connects to the primary using a mysql user for replicating. So there must be a mysql user account for the same on the primary host. Any user can be used for this purpose provided it has REPLICATION SLAVE privilege. If the sole purpose is replication then we can have a user with only the required privilege. On the primary host mysql> create user repl_user@ identified by 'xxxxx'; mysql> grant replication slave on *.* to repl_user@''; Obtaining Starting position from Primary Run the following command on the primary host mysql> show master status\\G *************************** 1. row *************************** File: mysql-bin.000001 Position: 73 Binlog_Do_DB: Binlog_Ignore_DB: Executed_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 1 row in set (0.00 sec) If we are working with binary log based replication, the top two output lines are the most important ones. That tells the current binlog on the primary host and till what position it has written. For fresh hosts we know that no data is written so we can directly set up replication using the very first binlog file and position 4. If we are setting up a replication from a backup, then that changes the way we obtain the starting position. For GTIDs, the executed_gtid_set is the value where primary is right now. Again, for a fresh setup, we don\u2019t have to specify anything about the starting point and it will start from the transaction id 1, but when we set up from a backup, the backup will contain the GTID positions till where backup has been taken. Setting up Replica The replication setup must know about the primary host, the user and password to connect, the binlog coordinates (for binlog based replication) or the GTID auto-position parameter. The following command is used for setting up change master to master_host = '', master_port = , master_user = 'repl_user', master_password = 'xxxxx', master_auto_position = 1; Note - the Change Master To command has been replaced with Change Replication Source To from Mysql 8.0.23 onwards, also all the master and slave keywords are replaced with source and replica . If it is binlog based replication, then instead of master_auto_position, we need to specify the binlog coordinates. master_log_file = 'mysql-bin.000001', master_log_pos = 4 Starting Replication and Check Status Now that everything is configured, we just need to start the replication on the replica via the following command start slave; OR from MySQL 8.0.23 onwards, start replica; Whether or not the replication is running successfully, we can determine by running the following command show slave status\\G OR from MySQL 8.0.23 onwards, show replica status\\G mysql> show replica status\\G *************************** 1. row *************************** Replica_IO_State: Waiting for master to send event Source_Host: Source_User: repl_user Source_Port: Connect_Retry: 60 Source_Log_File: mysql-bin.000001 Read_Source_Log_Pos: 852 Relay_Log_File: mysql-relay-bin.000002 Relay_Log_Pos: 1067 Relay_Source_Log_File: mysql-bin.000001 Replica_IO_Running: Yes Replica_SQL_Running: Yes Replicate_Do_DB: Replicate_Ignore_DB: Replicate_Do_Table: Replicate_Ignore_Table: Replicate_Wild_Do_Table: Replicate_Wild_Ignore_Table: Last_Errno: 0 Last_Error: Skip_Counter: 0 Exec_Source_Log_Pos: 852 Relay_Log_Space: 1283 Until_Condition: None Until_Log_File: Until_Log_Pos: 0 Source_SSL_Allowed: No Source_SSL_CA_File: Source_SSL_CA_Path: Source_SSL_Cert: Source_SSL_Cipher: Source_SSL_Key: Seconds_Behind_Source: 0 Source_SSL_Verify_Server_Cert: No Last_IO_Errno: 0 Last_IO_Error: Last_SQL_Errno: 0 Last_SQL_Error: Replicate_Ignore_Server_Ids: Source_Server_Id: 1 Source_UUID: e17d0920-d00e-11eb-a3e6-000d3aa00f87 Source_Info_File: mysql.slave_master_info SQL_Delay: 0 SQL_Remaining_Delay: NULL Replica_SQL_Running_State: Slave has read all relay log; waiting for more updates Source_Retry_Count: 86400 Source_Bind: Last_IO_Error_Timestamp: Last_SQL_Error_Timestamp: Source_SSL_Crl: Source_SSL_Crlpath: Retrieved_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 Executed_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 Auto_Position: 1 Replicate_Rewrite_DB: Channel_Name: Source_TLS_Version: Source_public_key_path: Get_Source_public_key: 0 Network_Namespace: 1 row in set (0.00 sec) Some of the parameters are explained below:- Relay_Source_Log_File - the primary\u2019s file where replica is currently reading from Execute_Source_Log_Pos - for the above file on which position is the replica reading currently from. These two parameters are of utmost importance when binlog based replication is used. Replica_IO_Running - IO thread of replica is running or not Replica_SQL_Running - SQL thread of replica is running or not Seconds_Behind_Source - the difference of seconds when a statement was executed on Primary and then on Replica. This indicates how much replication lag is there. Source_UUID - the uuid of the primary host Retrieved_Gtid_Set - the GTIDs fetched from the primary host by the replica to be executed. Executed_Gtid_Set - the GTIDs executed on the replica. This set remains the same for the entire cluster if the replicas are in sync. Auto_Position - it directs the replica to fetch the next GTID automatically Create a Replica for the already setup cluster The steps discussed in the previous section talks about the setting up replication on two fresh hosts. When we have to set up a replica for a host which is already serving applications, then the backup of the primary is used, either fresh backup taken for the replica (should only be done if the traffic it is serving is less) or use a recently taken backup. If the size of the databases on the MySQL primary server is small, less than 100G recommended, then mysqldump can be used to take backup along with the following options. mysqldump -uroot -p -hhost_ip -P3306 --all-databases --single-transaction --master-data=1 > primary_host.bkp --single-transaction - this option starts a transaction before taking the backup which ensures it is consistent. As transactions are isolated from each other, so no other writes affect the backup. --master-data - this option is required if binlog based replication is desired to be set up. It includes the binary log file and log file position in the backup file. When GTID mode is enabled and mysqldump is executed, it includes the GTID executed to be used to start the replica after the backup position. The contents of the mysqldump output file will have the following It is recommended to comment these before restoring otherwise they could throw errors. Also, using master-data=2 will automatically comment the master_log_file line. Similarly, when taking backup of the host using xtrabackup , the file xtrabckup_info file contains the information about binlog file and file position, as well as the GTID executed set. server_version = 8.0.25 start_time = 2021-06-22 03:45:17 end_time = 2021-06-22 03:45:20 lock_time = 0 binlog_pos = filename 'mysql-bin.000007', position '196', GTID of the last change 'e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-5' innodb_from_lsn = 0 innodb_to_lsn = 18153149 partial = N incremental = N format = file compressed = N encrypted = N Now, after setting MySQL server on the desired host, restore the backup taken from any one of the above methods. If the intended way is binlog based replication, then use the binlog file and position info in the following command change Replication Source to source_host = \u2018primary_ip\u2019, source_port = 3306, source_user = \u2018repl_user\u2019, source_password = \u2018xxxxx\u2019, source_log_file = \u2018mysql-bin.000007\u2019, source_log_pos = \u2018196\u2019; If the replication needs to be set via GITDs, then run the below command to tell the replica about the GTIDs already executed. On the Replica host, run th following commands reset master; set global gtid_purged = \u2018e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-5\u2019 change replication source to source_host = \u2018primary_ip\u2019, source_port = 3306, source_user = \u2018repl_user\u2019, source_password = \u2018xxxxx\u2019, source_auto_position = 1 The reset master command resets the position of the binary log to initial. It can be skipped if the host is a freshly installed MySQL, but we restored a backup so it is necessary. The gtid_purged global variable lets the replica know the GTIDs that have already been executed, so that the replication can start after that. Then in the change source command, we set the auto-position to 1 which automatically gets the next GTID to proceed.","title":"Setting up Replication"},{"location":"level101/databases_sql/replication/#further-reading","text":"More applications of Replication Automtaed Failovers using MySQL Orchestrator","title":"Further Reading"},{"location":"level101/databases_sql/select_query/","text":"SELECT Query The most commonly used command while working with MySQL is SELECT. It is used to fetch the result set from one or more tables. The general form of a typical select query looks like:- SELECT expr FROM table1 [WHERE condition] [GROUP BY column_list HAVING condition] [ORDER BY column_list ASC|DESC] [LIMIT #] The above general form contains some commonly used clauses of a SELECT query:- expr - comma-separated column list or * (for all columns) WHERE - a condition is provided, if true, directs the query to select only those records. GROUP BY - groups the entire result set based on the column list provided. An aggregate function is recommended to be present in the select expression of the query. HAVING supports grouping by putting a condition on the selected or any other aggregate function. ORDER BY - sorts the result set based on the column list in ascending or descending order. LIMIT - commonly used to limit the number of records. Let\u2019s have a look at some examples for a better understanding of the above. The dataset used for the examples below is available here and is free to use. Select all records mysql> select * from employees limit 5; +--------+------------+------------+-----------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-----------+--------+------------+ | 10001 | 1953-09-02 | Georgi | Facello | M | 1986-06-26 | | 10002 | 1964-06-02 | Bezalel | Simmel | F | 1985-11-21 | | 10003 | 1959-12-03 | Parto | Bamford | M | 1986-08-28 | | 10004 | 1954-05-01 | Chirstian | Koblick | M | 1986-12-01 | | 10005 | 1955-01-21 | Kyoichi | Maliniak | M | 1989-09-12 | +--------+------------+------------+-----------+--------+------------+ 5 rows in set (0.00 sec) Select specific fields for all records mysql> select first_name, last_name, gender from employees limit 5; +------------+-----------+--------+ | first_name | last_name | gender | +------------+-----------+--------+ | Georgi | Facello | M | | Bezalel | Simmel | F | | Parto | Bamford | M | | Chirstian | Koblick | M | | Kyoichi | Maliniak | M | +------------+-----------+--------+ 5 rows in set (0.00 sec) Select all records Where hire_date >= January 1, 1990 mysql> select * from employees where hire_date >= '1990-01-01' limit 5; +--------+------------+------------+-------------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-------------+--------+------------+ | 10008 | 1958-02-19 | Saniya | Kalloufi | M | 1994-09-15 | | 10011 | 1953-11-07 | Mary | Sluis | F | 1990-01-22 | | 10012 | 1960-10-04 | Patricio | Bridgland | M | 1992-12-18 | | 10016 | 1961-05-02 | Kazuhito | Cappelletti | M | 1995-01-27 | | 10017 | 1958-07-06 | Cristinel | Bouloucos | F | 1993-08-03 | +--------+------------+------------+-------------+--------+------------+ 5 rows in set (0.01 sec) Select first_name and last_name from all records Where birth_date >= 1960 AND gender = \u2018F\u2019 mysql> select first_name, last_name from employees where year(birth_date) >= 1960 and gender='F' limit 5; +------------+-----------+ | first_name | last_name | +------------+-----------+ | Bezalel | Simmel | | Duangkaew | Piveteau | | Divier | Reistad | | Jeong | Reistad | | Mingsen | Casley | +------------+-----------+ 5 rows in set (0.00 sec) Display the total number of records mysql> select count(*) from employees; +----------+ | count(*) | +----------+ | 300024 | +----------+ 1 row in set (0.05 sec) Display gender-wise count of all records mysql> select gender, count(*) from employees group by gender; +--------+----------+ | gender | count(*) | +--------+----------+ | M | 179973 | | F | 120051 | +--------+----------+ 2 rows in set (0.14 sec) Display the year of hire_date and number of employees hired that year, also only those years where more than 20k employees were hired mysql> select year(hire_date), count(*) from employees group by year(hire_date) having count(*) > 20000; +-----------------+----------+ | year(hire_date) | count(*) | +-----------------+----------+ | 1985 | 35316 | | 1986 | 36150 | | 1987 | 33501 | | 1988 | 31436 | | 1989 | 28394 | | 1990 | 25610 | | 1991 | 22568 | | 1992 | 20402 | +-----------------+----------+ 8 rows in set (0.14 sec) Display all records ordered by their hire_date in descending order. If hire_date is the same then in order of their birth_date ascending order mysql> select * from employees order by hire_date desc, birth_date asc limit 5; +--------+------------+------------+-----------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-----------+--------+------------+ | 463807 | 1964-06-12 | Bikash | Covnot | M | 2000-01-28 | | 428377 | 1957-05-09 | Yucai | Gerlach | M | 2000-01-23 | | 499553 | 1954-05-06 | Hideyuki | Delgrande | F | 2000-01-22 | | 222965 | 1959-08-07 | Volkmar | Perko | F | 2000-01-13 | | 47291 | 1960-09-09 | Ulf | Flexer | M | 2000-01-12 | +--------+------------+------------+-----------+--------+------------+ 5 rows in set (0.12 sec) SELECT - JOINS JOIN statement is used to produce a combined result set from two or more tables based on certain conditions. It can be also used with Update and Delete statements but we will be focussing on the select query. Following is a basic general form for joins SELECT table1.col1, table2.col1, ... (any combination) FROM table1 table2 ON (or USING depends on join_type) table1.column_for_joining = table2.column_for_joining WHERE \u2026 Any number of columns can be selected, but it is recommended to select only those which are relevant to increase the readability of the resultset. All other clauses like where, group by are not mandatory. Let\u2019s discuss the types of JOINs supported by MySQL Syntax. Inner Join This joins table A with table B on a condition. Only the records where the condition is True are selected in the resultset. Display some details of employees along with their salary mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e join salaries s on e.emp_no=s.emp_no limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Similar result can be achieved by mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e join salaries s using (emp_no) limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) And also by mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e natural join salaries s limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Outer Join Majorly of two types:- - LEFT - joining complete table A with table B on a condition. All the records from table A are selected, but from table B, only those records are selected where the condition is True. - RIGHT - Exact opposite of the left join. Let us assume the below tables for understanding left join better. mysql> select * from dummy1; +----------+------------+ | same_col | diff_col_1 | +----------+------------+ | 1 | A | | 2 | B | | 3 | C | +----------+------------+ mysql> select * from dummy2; +----------+------------+ | same_col | diff_col_2 | +----------+------------+ | 1 | X | | 3 | Y | +----------+------------+ A simple select join will look like the one below. mysql> select * from dummy1 d1 left join dummy2 d2 on d1.same_col=d2.same_col; +----------+------------+----------+------------+ | same_col | diff_col_1 | same_col | diff_col_2 | +----------+------------+----------+------------+ | 1 | A | 1 | X | | 3 | C | 3 | Y | | 2 | B | NULL | NULL | +----------+------------+----------+------------+ 3 rows in set (0.00 sec) Which can also be written as mysql> select * from dummy1 d1 left join dummy2 d2 using(same_col); +----------+------------+------------+ | same_col | diff_col_1 | diff_col_2 | +----------+------------+------------+ | 1 | A | X | | 3 | C | Y | | 2 | B | NULL | +----------+------------+------------+ 3 rows in set (0.00 sec) And also as mysql> select * from dummy1 d1 natural left join dummy2 d2; +----------+------------+------------+ | same_col | diff_col_1 | diff_col_2 | +----------+------------+------------+ | 1 | A | X | | 3 | C | Y | | 2 | B | NULL | +----------+------------+------------+ 3 rows in set (0.00 sec) Cross Join This does a cross product of table A and table B without any condition. It doesn\u2019t have a lot of applications in the real world. A Simple Cross Join looks like this mysql> select * from dummy1 cross join dummy2; +----------+------------+----------+------------+ | same_col | diff_col_1 | same_col | diff_col_2 | +----------+------------+----------+------------+ | 1 | A | 3 | Y | | 1 | A | 1 | X | | 2 | B | 3 | Y | | 2 | B | 1 | X | | 3 | C | 3 | Y | | 3 | C | 1 | X | +----------+------------+----------+------------+ 6 rows in set (0.01 sec) One use case that can come in handy is when you have to fill in some missing entries. For example, all the entries from dummy1 must be inserted into a similar table dummy3, with each record must have 3 entries with statuses 1, 5 and 7. mysql> desc dummy3; +----------+----------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +----------+----------+------+-----+---------+-------+ | same_col | int | YES | | NULL | | | value | char(15) | YES | | NULL | | | status | smallint | YES | | NULL | | +----------+----------+------+-----+---------+-------+ 3 rows in set (0.02 sec) Either you create an insert query script with as many entries as in dummy1 or use cross join to produce the required resultset. mysql> select * from dummy1 cross join (select 1 union select 5 union select 7) T2 order by same_col; +----------+------------+---+ | same_col | diff_col_1 | 1 | +----------+------------+---+ | 1 | A | 1 | | 1 | A | 5 | | 1 | A | 7 | | 2 | B | 1 | | 2 | B | 5 | | 2 | B | 7 | | 3 | C | 1 | | 3 | C | 5 | | 3 | C | 7 | +----------+------------+---+ 9 rows in set (0.00 sec) The T2 section in the above query is called a sub-query . We will discuss the same in the next section. Natural Join This implicitly selects the common column from table A and table B and performs an inner join. mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e natural join salaries s limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Notice how natural join and using takes care that the common column is displayed only once if you are not explicitly selecting columns for the query. Some More Examples Display emp_no, salary, title and dept of the employees where salary > 80000 mysql> select e.emp_no, s.salary, t.title, d.dept_no from employees e join salaries s using (emp_no) join titles t using (emp_no) join dept_emp d using (emp_no) where s.salary > 80000 limit 5; +--------+--------+--------------+---------+ | emp_no | salary | title | dept_no | +--------+--------+--------------+---------+ | 10017 | 82163 | Senior Staff | d001 | | 10017 | 86157 | Senior Staff | d001 | | 10017 | 89619 | Senior Staff | d001 | | 10017 | 91985 | Senior Staff | d001 | | 10017 | 96122 | Senior Staff | d001 | +--------+--------+--------------+---------+ 5 rows in set (0.00 sec) Display title-wise count of employees in each department order by dept_no mysql> select d.dept_no, t.title, count(*) from titles t left join dept_emp d using (emp_no) group by d.dept_no, t.title order by d.dept_no limit 10; +---------+--------------------+----------+ | dept_no | title | count(*) | +---------+--------------------+----------+ | d001 | Manager | 2 | | d001 | Senior Staff | 13940 | | d001 | Staff | 16196 | | d002 | Manager | 2 | | d002 | Senior Staff | 12139 | | d002 | Staff | 13929 | | d003 | Manager | 2 | | d003 | Senior Staff | 12274 | | d003 | Staff | 14342 | | d004 | Assistant Engineer | 6445 | +---------+--------------------+----------+ 10 rows in set (1.32 sec) SELECT - Subquery A subquery is generally a smaller resultset that can be used to power a select query in many ways. It can be used in a \u2018where\u2019 condition, can be used in place of join mostly where a join could be an overkill. These subqueries are also termed as derived tables. They must have a table alias in the select query. Let\u2019s look at some examples of subqueries. Here we got the department name from the departments table by a subquery which used dept_no from dept_emp table. mysql> select e.emp_no, (select dept_name from departments where dept_no=d.dept_no) dept_name from employees e join dept_emp d using (emp_no) limit 5; +--------+-----------------+ | emp_no | dept_name | +--------+-----------------+ | 10001 | Development | | 10002 | Sales | | 10003 | Production | | 10004 | Production | | 10005 | Human Resources | +--------+-----------------+ 5 rows in set (0.01 sec) Here, we used the \u2018avg\u2019 query above (which got the avg salary) as a subquery to list the employees whose latest salary is more than the average. mysql> select avg(salary) from salaries; +-------------+ | avg(salary) | +-------------+ | 63810.7448 | +-------------+ 1 row in set (0.80 sec) mysql> select e.emp_no, max(s.salary) from employees e natural join salaries s group by e.emp_no having max(s.salary) > (select avg(salary) from salaries) limit 10; +--------+---------------+ | emp_no | max(s.salary) | +--------+---------------+ | 10001 | 88958 | | 10002 | 72527 | | 10004 | 74057 | | 10005 | 94692 | | 10007 | 88070 | | 10009 | 94443 | | 10010 | 80324 | | 10013 | 68901 | | 10016 | 77935 | | 10017 | 99651 | +--------+---------------+ 10 rows in set (0.56 sec)","title":"Select Query"},{"location":"level101/databases_sql/select_query/#select-query","text":"The most commonly used command while working with MySQL is SELECT. It is used to fetch the result set from one or more tables. The general form of a typical select query looks like:- SELECT expr FROM table1 [WHERE condition] [GROUP BY column_list HAVING condition] [ORDER BY column_list ASC|DESC] [LIMIT #] The above general form contains some commonly used clauses of a SELECT query:- expr - comma-separated column list or * (for all columns) WHERE - a condition is provided, if true, directs the query to select only those records. GROUP BY - groups the entire result set based on the column list provided. An aggregate function is recommended to be present in the select expression of the query. HAVING supports grouping by putting a condition on the selected or any other aggregate function. ORDER BY - sorts the result set based on the column list in ascending or descending order. LIMIT - commonly used to limit the number of records. Let\u2019s have a look at some examples for a better understanding of the above. The dataset used for the examples below is available here and is free to use. Select all records mysql> select * from employees limit 5; +--------+------------+------------+-----------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-----------+--------+------------+ | 10001 | 1953-09-02 | Georgi | Facello | M | 1986-06-26 | | 10002 | 1964-06-02 | Bezalel | Simmel | F | 1985-11-21 | | 10003 | 1959-12-03 | Parto | Bamford | M | 1986-08-28 | | 10004 | 1954-05-01 | Chirstian | Koblick | M | 1986-12-01 | | 10005 | 1955-01-21 | Kyoichi | Maliniak | M | 1989-09-12 | +--------+------------+------------+-----------+--------+------------+ 5 rows in set (0.00 sec) Select specific fields for all records mysql> select first_name, last_name, gender from employees limit 5; +------------+-----------+--------+ | first_name | last_name | gender | +------------+-----------+--------+ | Georgi | Facello | M | | Bezalel | Simmel | F | | Parto | Bamford | M | | Chirstian | Koblick | M | | Kyoichi | Maliniak | M | +------------+-----------+--------+ 5 rows in set (0.00 sec) Select all records Where hire_date >= January 1, 1990 mysql> select * from employees where hire_date >= '1990-01-01' limit 5; +--------+------------+------------+-------------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-------------+--------+------------+ | 10008 | 1958-02-19 | Saniya | Kalloufi | M | 1994-09-15 | | 10011 | 1953-11-07 | Mary | Sluis | F | 1990-01-22 | | 10012 | 1960-10-04 | Patricio | Bridgland | M | 1992-12-18 | | 10016 | 1961-05-02 | Kazuhito | Cappelletti | M | 1995-01-27 | | 10017 | 1958-07-06 | Cristinel | Bouloucos | F | 1993-08-03 | +--------+------------+------------+-------------+--------+------------+ 5 rows in set (0.01 sec) Select first_name and last_name from all records Where birth_date >= 1960 AND gender = \u2018F\u2019 mysql> select first_name, last_name from employees where year(birth_date) >= 1960 and gender='F' limit 5; +------------+-----------+ | first_name | last_name | +------------+-----------+ | Bezalel | Simmel | | Duangkaew | Piveteau | | Divier | Reistad | | Jeong | Reistad | | Mingsen | Casley | +------------+-----------+ 5 rows in set (0.00 sec) Display the total number of records mysql> select count(*) from employees; +----------+ | count(*) | +----------+ | 300024 | +----------+ 1 row in set (0.05 sec) Display gender-wise count of all records mysql> select gender, count(*) from employees group by gender; +--------+----------+ | gender | count(*) | +--------+----------+ | M | 179973 | | F | 120051 | +--------+----------+ 2 rows in set (0.14 sec) Display the year of hire_date and number of employees hired that year, also only those years where more than 20k employees were hired mysql> select year(hire_date), count(*) from employees group by year(hire_date) having count(*) > 20000; +-----------------+----------+ | year(hire_date) | count(*) | +-----------------+----------+ | 1985 | 35316 | | 1986 | 36150 | | 1987 | 33501 | | 1988 | 31436 | | 1989 | 28394 | | 1990 | 25610 | | 1991 | 22568 | | 1992 | 20402 | +-----------------+----------+ 8 rows in set (0.14 sec) Display all records ordered by their hire_date in descending order. If hire_date is the same then in order of their birth_date ascending order mysql> select * from employees order by hire_date desc, birth_date asc limit 5; +--------+------------+------------+-----------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-----------+--------+------------+ | 463807 | 1964-06-12 | Bikash | Covnot | M | 2000-01-28 | | 428377 | 1957-05-09 | Yucai | Gerlach | M | 2000-01-23 | | 499553 | 1954-05-06 | Hideyuki | Delgrande | F | 2000-01-22 | | 222965 | 1959-08-07 | Volkmar | Perko | F | 2000-01-13 | | 47291 | 1960-09-09 | Ulf | Flexer | M | 2000-01-12 | +--------+------------+------------+-----------+--------+------------+ 5 rows in set (0.12 sec)","title":"SELECT Query"},{"location":"level101/databases_sql/select_query/#select-joins","text":"JOIN statement is used to produce a combined result set from two or more tables based on certain conditions. It can be also used with Update and Delete statements but we will be focussing on the select query. Following is a basic general form for joins SELECT table1.col1, table2.col1, ... (any combination) FROM table1 table2 ON (or USING depends on join_type) table1.column_for_joining = table2.column_for_joining WHERE \u2026 Any number of columns can be selected, but it is recommended to select only those which are relevant to increase the readability of the resultset. All other clauses like where, group by are not mandatory. Let\u2019s discuss the types of JOINs supported by MySQL Syntax. Inner Join This joins table A with table B on a condition. Only the records where the condition is True are selected in the resultset. Display some details of employees along with their salary mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e join salaries s on e.emp_no=s.emp_no limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Similar result can be achieved by mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e join salaries s using (emp_no) limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) And also by mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e natural join salaries s limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Outer Join Majorly of two types:- - LEFT - joining complete table A with table B on a condition. All the records from table A are selected, but from table B, only those records are selected where the condition is True. - RIGHT - Exact opposite of the left join. Let us assume the below tables for understanding left join better. mysql> select * from dummy1; +----------+------------+ | same_col | diff_col_1 | +----------+------------+ | 1 | A | | 2 | B | | 3 | C | +----------+------------+ mysql> select * from dummy2; +----------+------------+ | same_col | diff_col_2 | +----------+------------+ | 1 | X | | 3 | Y | +----------+------------+ A simple select join will look like the one below. mysql> select * from dummy1 d1 left join dummy2 d2 on d1.same_col=d2.same_col; +----------+------------+----------+------------+ | same_col | diff_col_1 | same_col | diff_col_2 | +----------+------------+----------+------------+ | 1 | A | 1 | X | | 3 | C | 3 | Y | | 2 | B | NULL | NULL | +----------+------------+----------+------------+ 3 rows in set (0.00 sec) Which can also be written as mysql> select * from dummy1 d1 left join dummy2 d2 using(same_col); +----------+------------+------------+ | same_col | diff_col_1 | diff_col_2 | +----------+------------+------------+ | 1 | A | X | | 3 | C | Y | | 2 | B | NULL | +----------+------------+------------+ 3 rows in set (0.00 sec) And also as mysql> select * from dummy1 d1 natural left join dummy2 d2; +----------+------------+------------+ | same_col | diff_col_1 | diff_col_2 | +----------+------------+------------+ | 1 | A | X | | 3 | C | Y | | 2 | B | NULL | +----------+------------+------------+ 3 rows in set (0.00 sec) Cross Join This does a cross product of table A and table B without any condition. It doesn\u2019t have a lot of applications in the real world. A Simple Cross Join looks like this mysql> select * from dummy1 cross join dummy2; +----------+------------+----------+------------+ | same_col | diff_col_1 | same_col | diff_col_2 | +----------+------------+----------+------------+ | 1 | A | 3 | Y | | 1 | A | 1 | X | | 2 | B | 3 | Y | | 2 | B | 1 | X | | 3 | C | 3 | Y | | 3 | C | 1 | X | +----------+------------+----------+------------+ 6 rows in set (0.01 sec) One use case that can come in handy is when you have to fill in some missing entries. For example, all the entries from dummy1 must be inserted into a similar table dummy3, with each record must have 3 entries with statuses 1, 5 and 7. mysql> desc dummy3; +----------+----------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +----------+----------+------+-----+---------+-------+ | same_col | int | YES | | NULL | | | value | char(15) | YES | | NULL | | | status | smallint | YES | | NULL | | +----------+----------+------+-----+---------+-------+ 3 rows in set (0.02 sec) Either you create an insert query script with as many entries as in dummy1 or use cross join to produce the required resultset. mysql> select * from dummy1 cross join (select 1 union select 5 union select 7) T2 order by same_col; +----------+------------+---+ | same_col | diff_col_1 | 1 | +----------+------------+---+ | 1 | A | 1 | | 1 | A | 5 | | 1 | A | 7 | | 2 | B | 1 | | 2 | B | 5 | | 2 | B | 7 | | 3 | C | 1 | | 3 | C | 5 | | 3 | C | 7 | +----------+------------+---+ 9 rows in set (0.00 sec) The T2 section in the above query is called a sub-query . We will discuss the same in the next section. Natural Join This implicitly selects the common column from table A and table B and performs an inner join. mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e natural join salaries s limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Notice how natural join and using takes care that the common column is displayed only once if you are not explicitly selecting columns for the query. Some More Examples Display emp_no, salary, title and dept of the employees where salary > 80000 mysql> select e.emp_no, s.salary, t.title, d.dept_no from employees e join salaries s using (emp_no) join titles t using (emp_no) join dept_emp d using (emp_no) where s.salary > 80000 limit 5; +--------+--------+--------------+---------+ | emp_no | salary | title | dept_no | +--------+--------+--------------+---------+ | 10017 | 82163 | Senior Staff | d001 | | 10017 | 86157 | Senior Staff | d001 | | 10017 | 89619 | Senior Staff | d001 | | 10017 | 91985 | Senior Staff | d001 | | 10017 | 96122 | Senior Staff | d001 | +--------+--------+--------------+---------+ 5 rows in set (0.00 sec) Display title-wise count of employees in each department order by dept_no mysql> select d.dept_no, t.title, count(*) from titles t left join dept_emp d using (emp_no) group by d.dept_no, t.title order by d.dept_no limit 10; +---------+--------------------+----------+ | dept_no | title | count(*) | +---------+--------------------+----------+ | d001 | Manager | 2 | | d001 | Senior Staff | 13940 | | d001 | Staff | 16196 | | d002 | Manager | 2 | | d002 | Senior Staff | 12139 | | d002 | Staff | 13929 | | d003 | Manager | 2 | | d003 | Senior Staff | 12274 | | d003 | Staff | 14342 | | d004 | Assistant Engineer | 6445 | +---------+--------------------+----------+ 10 rows in set (1.32 sec)","title":"SELECT - JOINS"},{"location":"level101/databases_sql/select_query/#select-subquery","text":"A subquery is generally a smaller resultset that can be used to power a select query in many ways. It can be used in a \u2018where\u2019 condition, can be used in place of join mostly where a join could be an overkill. These subqueries are also termed as derived tables. They must have a table alias in the select query. Let\u2019s look at some examples of subqueries. Here we got the department name from the departments table by a subquery which used dept_no from dept_emp table. mysql> select e.emp_no, (select dept_name from departments where dept_no=d.dept_no) dept_name from employees e join dept_emp d using (emp_no) limit 5; +--------+-----------------+ | emp_no | dept_name | +--------+-----------------+ | 10001 | Development | | 10002 | Sales | | 10003 | Production | | 10004 | Production | | 10005 | Human Resources | +--------+-----------------+ 5 rows in set (0.01 sec) Here, we used the \u2018avg\u2019 query above (which got the avg salary) as a subquery to list the employees whose latest salary is more than the average. mysql> select avg(salary) from salaries; +-------------+ | avg(salary) | +-------------+ | 63810.7448 | +-------------+ 1 row in set (0.80 sec) mysql> select e.emp_no, max(s.salary) from employees e natural join salaries s group by e.emp_no having max(s.salary) > (select avg(salary) from salaries) limit 10; +--------+---------------+ | emp_no | max(s.salary) | +--------+---------------+ | 10001 | 88958 | | 10002 | 72527 | | 10004 | 74057 | | 10005 | 94692 | | 10007 | 88070 | | 10009 | 94443 | | 10010 | 80324 | | 10013 | 68901 | | 10016 | 77935 | | 10017 | 99651 | +--------+---------------+ 10 rows in set (0.56 sec)","title":"SELECT - Subquery"},{"location":"level101/git/branches/","text":"Working With Branches Coming back to our local repo which has two commits. So far, what we have is a single line of history. Commits are chained in a single line. But sometimes you may have a need to work on two different features in parallel in the same repo. Now one option here could be making a new folder/repo with the same code and use that for another feature development. But there's a better way. Use branches. Since git follows tree like structure for commits, we can use branches to work on different sets of features. From a commit, two or more branches can be created and branches can also be merged. Using branches, there can exist multiple lines of histories and we can checkout to any of them and work on it. Checking out, as we discussed earlier, would simply mean replacing contents of the directory (repo) with the snapshot at the checked out version. Let's create a branch and see how it looks like: $ git branch b1 $ git log --oneline --graph * 7f3b00e (HEAD -> master, b1) adding file 2 * df2fb7a adding file 1 We create a branch called b1 . Git log tells us that b1 also points to the last commit (7f3b00e) but the HEAD is still pointing to master. If you remember, HEAD points to the commit/reference wherever you are checkout to. So if we checkout to b1 , HEAD should point to that. Let's confirm: $ git checkout b1 Switched to branch 'b1' $ git log --oneline --graph * 7f3b00e (HEAD -> b1, master) adding file 2 * df2fb7a adding file 1 b1 still points to the same commit but HEAD now points to b1 . Since we create a branch at commit 7f3b00e , there will be two lines of histories starting this commit. Depending on which branch you are checked out on, the line of history will progress. At this moment, we are checked out on branch b1 , so making a new commit will advance branch reference b1 to that commit and current b1 commit will become its parent. Let's do that. # Creating a file and making a commit $ echo \"I am a file in b1 branch\" > b1.txt $ git add b1.txt $ git commit -m \"adding b1 file\" [b1 872a38f] adding b1 file 1 file changed, 1 insertion(+) create mode 100644 b1.txt # The new line of history $ git log --oneline --graph * 872a38f (HEAD -> b1) adding b1 file * 7f3b00e (master) adding file 2 * df2fb7a adding file 1 $ Do note that master is still pointing to the old commit it was pointing to. We can now checkout to master branch and make commits there. This will result in another line of history starting from commit 7f3b00e. # checkout to master branch $ git checkout master Switched to branch 'master' # Creating a new commit on master branch $ echo \"new file in master branch\" > master.txt $ git add master.txt $ git commit -m \"adding master.txt file\" [master 60dc441] adding master.txt file 1 file changed, 1 insertion(+) create mode 100644 master.txt # The history line $ git log --oneline --graph * 60dc441 (HEAD -> master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 Notice how branch b1 is not visible here since we are on the master. Let's try to visualize both to get the whole picture: $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Above tree structure should make things clear. Notice a clear branch/fork on commit 7f3b00e. This is how we create branches. Now they both are two separate lines of history on which feature development can be done independently. To reiterate, internally, git is just a tree of commits. Branch names (human readable) are pointers to those commits in the tree. We use various git commands to work with the tree structure and references. Git accordingly modifies contents of our repo. Merges Now say the feature you were working on branch b1 is complete and you need to merge it on master branch, where all the final version of code goes. So first you will checkout to branch master and then you pull the latest code from upstream (eg: GitHub). Then you need to merge your code from b1 into master. There could be two ways this can be done. Here is the current history: $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Option 1: Directly merge the branch. Merging the branch b1 into master will result in a new merge commit. This will merge changes from two different lines of history and create a new commit of the result. $ git merge b1 Merge made by the 'recursive' strategy. b1.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 b1.txt $ git log --oneline --graph --all * 8fc28f9 (HEAD -> master) Merge branch 'b1' |\\ | * 872a38f (b1) adding b1 file * | 60dc441 adding master.txt file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 You can see a new merge commit created (8fc28f9). You will be prompted for the commit message. If there are a lot of branches in the repo, this result will end-up with a lot of merge commits. Which looks ugly compared to a single line of history of development. So let's look at an alternative approach First let's reset our last merge and go to the previous state. $ git reset --hard 60dc441 HEAD is now at 60dc441 adding master.txt file $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Option 2: Rebase. Now, instead of merging two branches which has a similar base (commit: 7f3b00e), let us rebase branch b1 on to current master. What this means is take branch b1 (from commit 7f3b00e to commit 872a38f) and rebase (put them on top of) master (60dc441). # Switch to b1 $ git checkout b1 Switched to branch 'b1' # Rebase (b1 which is current branch) on master $ git rebase master First, rewinding head to replay your work on top of it... Applying: adding b1 file # The result $ git log --oneline --graph --all * 5372c8f (HEAD -> b1) adding b1 file * 60dc441 (master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 You can see b1 which had 1 commit. That commit's parent was 7f3b00e . But since we rebase it on master ( 60dc441 ). That becomes the parent now. As a side effect, you also see it has become a single line of history. Now if we were to merge b1 into master , it would simply mean change master to point to 5372c8f which is b1 . Let's try it: # checkout to master since we want to merge code into master $ git checkout master Switched to branch 'master' # the current history, where b1 is based on master $ git log --oneline --graph --all * 5372c8f (b1) adding b1 file * 60dc441 (HEAD -> master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 # Performing the merge, notice the \"fast-forward\" message $ git merge b1 Updating 60dc441..5372c8f Fast-forward b1.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 b1.txt # The Result $ git log --oneline --graph --all * 5372c8f (HEAD -> master, b1) adding b1 file * 60dc441 adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 Now you see both b1 and master are pointing to the same commit. Your code has been merged to the master branch and it can be pushed. Also we have clean line of history! :D","title":"Working With Branches"},{"location":"level101/git/branches/#working-with-branches","text":"Coming back to our local repo which has two commits. So far, what we have is a single line of history. Commits are chained in a single line. But sometimes you may have a need to work on two different features in parallel in the same repo. Now one option here could be making a new folder/repo with the same code and use that for another feature development. But there's a better way. Use branches. Since git follows tree like structure for commits, we can use branches to work on different sets of features. From a commit, two or more branches can be created and branches can also be merged. Using branches, there can exist multiple lines of histories and we can checkout to any of them and work on it. Checking out, as we discussed earlier, would simply mean replacing contents of the directory (repo) with the snapshot at the checked out version. Let's create a branch and see how it looks like: $ git branch b1 $ git log --oneline --graph * 7f3b00e (HEAD -> master, b1) adding file 2 * df2fb7a adding file 1 We create a branch called b1 . Git log tells us that b1 also points to the last commit (7f3b00e) but the HEAD is still pointing to master. If you remember, HEAD points to the commit/reference wherever you are checkout to. So if we checkout to b1 , HEAD should point to that. Let's confirm: $ git checkout b1 Switched to branch 'b1' $ git log --oneline --graph * 7f3b00e (HEAD -> b1, master) adding file 2 * df2fb7a adding file 1 b1 still points to the same commit but HEAD now points to b1 . Since we create a branch at commit 7f3b00e , there will be two lines of histories starting this commit. Depending on which branch you are checked out on, the line of history will progress. At this moment, we are checked out on branch b1 , so making a new commit will advance branch reference b1 to that commit and current b1 commit will become its parent. Let's do that. # Creating a file and making a commit $ echo \"I am a file in b1 branch\" > b1.txt $ git add b1.txt $ git commit -m \"adding b1 file\" [b1 872a38f] adding b1 file 1 file changed, 1 insertion(+) create mode 100644 b1.txt # The new line of history $ git log --oneline --graph * 872a38f (HEAD -> b1) adding b1 file * 7f3b00e (master) adding file 2 * df2fb7a adding file 1 $ Do note that master is still pointing to the old commit it was pointing to. We can now checkout to master branch and make commits there. This will result in another line of history starting from commit 7f3b00e. # checkout to master branch $ git checkout master Switched to branch 'master' # Creating a new commit on master branch $ echo \"new file in master branch\" > master.txt $ git add master.txt $ git commit -m \"adding master.txt file\" [master 60dc441] adding master.txt file 1 file changed, 1 insertion(+) create mode 100644 master.txt # The history line $ git log --oneline --graph * 60dc441 (HEAD -> master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 Notice how branch b1 is not visible here since we are on the master. Let's try to visualize both to get the whole picture: $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Above tree structure should make things clear. Notice a clear branch/fork on commit 7f3b00e. This is how we create branches. Now they both are two separate lines of history on which feature development can be done independently. To reiterate, internally, git is just a tree of commits. Branch names (human readable) are pointers to those commits in the tree. We use various git commands to work with the tree structure and references. Git accordingly modifies contents of our repo.","title":"Working With Branches"},{"location":"level101/git/branches/#merges","text":"Now say the feature you were working on branch b1 is complete and you need to merge it on master branch, where all the final version of code goes. So first you will checkout to branch master and then you pull the latest code from upstream (eg: GitHub). Then you need to merge your code from b1 into master. There could be two ways this can be done. Here is the current history: $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Option 1: Directly merge the branch. Merging the branch b1 into master will result in a new merge commit. This will merge changes from two different lines of history and create a new commit of the result. $ git merge b1 Merge made by the 'recursive' strategy. b1.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 b1.txt $ git log --oneline --graph --all * 8fc28f9 (HEAD -> master) Merge branch 'b1' |\\ | * 872a38f (b1) adding b1 file * | 60dc441 adding master.txt file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 You can see a new merge commit created (8fc28f9). You will be prompted for the commit message. If there are a lot of branches in the repo, this result will end-up with a lot of merge commits. Which looks ugly compared to a single line of history of development. So let's look at an alternative approach First let's reset our last merge and go to the previous state. $ git reset --hard 60dc441 HEAD is now at 60dc441 adding master.txt file $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Option 2: Rebase. Now, instead of merging two branches which has a similar base (commit: 7f3b00e), let us rebase branch b1 on to current master. What this means is take branch b1 (from commit 7f3b00e to commit 872a38f) and rebase (put them on top of) master (60dc441). # Switch to b1 $ git checkout b1 Switched to branch 'b1' # Rebase (b1 which is current branch) on master $ git rebase master First, rewinding head to replay your work on top of it... Applying: adding b1 file # The result $ git log --oneline --graph --all * 5372c8f (HEAD -> b1) adding b1 file * 60dc441 (master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 You can see b1 which had 1 commit. That commit's parent was 7f3b00e . But since we rebase it on master ( 60dc441 ). That becomes the parent now. As a side effect, you also see it has become a single line of history. Now if we were to merge b1 into master , it would simply mean change master to point to 5372c8f which is b1 . Let's try it: # checkout to master since we want to merge code into master $ git checkout master Switched to branch 'master' # the current history, where b1 is based on master $ git log --oneline --graph --all * 5372c8f (b1) adding b1 file * 60dc441 (HEAD -> master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 # Performing the merge, notice the \"fast-forward\" message $ git merge b1 Updating 60dc441..5372c8f Fast-forward b1.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 b1.txt # The Result $ git log --oneline --graph --all * 5372c8f (HEAD -> master, b1) adding b1 file * 60dc441 adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 Now you see both b1 and master are pointing to the same commit. Your code has been merged to the master branch and it can be pushed. Also we have clean line of history! :D","title":"Merges"},{"location":"level101/git/conclusion/","text":"What next from here? There are a lot of git commands and features which we have not explored here. But with the base built-up, be sure to explore concepts like Cherrypick Squash Amend Stash Reset","title":"Conclusion"},{"location":"level101/git/conclusion/#what-next-from-here","text":"There are a lot of git commands and features which we have not explored here. But with the base built-up, be sure to explore concepts like Cherrypick Squash Amend Stash Reset","title":"What next from here?"},{"location":"level101/git/git-basics/","text":"Git Prerequisites Have Git installed https://git-scm.com/downloads Have taken any git high level tutorial or following LinkedIn learning courses https://www.linkedin.com/learning/git-essential-training-the-basics/ https://www.linkedin.com/learning/git-branches-merges-and-remotes/ The Official Git Docs What to expect from this course As an engineer in the field of computer science, having knowledge of version control tools becomes almost a requirement. While there are a lot of version control tools that exist today like SVN, Mercurial, etc, Git perhaps is the most used one and this course we will be working with Git. While this course does not start with Git 101 and expects basic knowledge of git as a prerequisite, it will reintroduce the git concepts known by you with details covering what is happening under the hood as you execute various git commands. So that next time you run a git command, you will be able to press enter more confidently! What is not covered under this course Advanced usage and specifics of internal implementation details of Git. Course Contents Git Basics Working with Branches Git with Github Hooks Git Basics Though you might be aware already, let's revisit why we need a version control system. As the project grows and multiple developers start working on it, an efficient method for collaboration is warranted. Git helps the team collaborate easily and also maintains the history of the changes happening with the codebase. Creating a Git Repo Any folder can be converted into a git repository. After executing the following command, we will see a .git folder within the folder, which makes our folder a git repository. All the magic that git does, .git folder is the enabler for the same. # creating an empty folder and changing current dir to it $ cd /tmp $ mkdir school-of-sre $ cd school-of-sre/ # initialize a git repo $ git init Initialized empty Git repository in /private/tmp/school-of-sre/.git/ As the output says, an empty git repo has been initialized in our folder. Let's take a look at what is there. $ ls .git/ HEAD config description hooks info objects refs There are a bunch of folders and files in the .git folder. As I said, all these enables git to do its magic. We will look into some of these folders and files. But for now, what we have is an empty git repository. Tracking a File Now as you might already know, let us create a new file in our repo (we will refer to the folder as repo now.) And see git status $ echo \"I am file 1\" > file1.txt $ git status On branch master No commits yet Untracked files: (use \"git add ...\" to include in what will be committed) file1.txt nothing added to commit but untracked files present (use \"git add\" to track) The current git status says No commits yet and there is one untracked file. Since we just created the file, git is not tracking that file. We explicitly need to ask git to track files and folders. (also checkout gitignore ) And how we do that is via git add command as suggested in the above output. Then we go ahead and create a commit. $ git add file1.txt $ git status On branch master No commits yet Changes to be committed: (use \"git rm --cached ...\" to unstage) new file: file1.txt $ git commit -m \"adding file 1\" [master (root-commit) df2fb7a] adding file 1 1 file changed, 1 insertion(+) create mode 100644 file1.txt Notice how after adding the file, git status says Changes to be committed: . What it means is whatever is listed there, will be included in the next commit. Then we go ahead and create a commit, with an attached messaged via -m . More About a Commit Commit is a snapshot of the repo. Whenever a commit is made, a snapshot of the current state of repo (the folder) is taken and saved. Each commit has a unique ID. ( df2fb7a for the commit we made in the previous step). As we keep adding/changing more and more contents and keep making commits, all those snapshots are stored by git. Again, all this magic happens inside the .git folder. This is where all this snapshot or versions are stored in an efficient manner. Adding More Changes Let us create one more file and commit the change. It would look the same as the previous commit we made. $ echo \"I am file 2\" > file2.txt $ git add file2.txt $ git commit -m \"adding file 2\" [master 7f3b00e] adding file 2 1 file changed, 1 insertion(+) create mode 100644 file2.txt A new commit with ID 7f3b00e has been created. You can issue git status at any time to see the state of the repository. **IMPORTANT: Note that commit IDs are long string (SHA) but we can refer to a commit by its initial few (8 or more) characters too. We will interchangeably using shorter and longer commit IDs.** Now that we have two commits, let's visualize them: $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 git log , as the name suggests, prints the log of all the git commits. Here you see two additional arguments, --oneline prints the shorter version of the log, ie: the commit message only and not the person who made the commit and when. --graph prints it in graph format. Now at this moment the commits might look like just one in each line but all commits are stored as a tree like data structure internally by git. That means there can be two or more children commits of a given commit. And not just a single line of commits. We will look more into this part when we get to the Branches section. For now this is our commit history: df2fb7a ===> 7f3b00e Are commits really linked? As I just said, the two commits we just made are linked via tree like data structure and we saw how they are linked. But let's actually verify it. Everything in git is an object. Newly created files are stored as an object. Changes to file are stored as an objects and even commits are objects. To view contents of an object we can use the following command with the object's ID. We will take a look at the contents of the second commit $ git cat-file -p 7f3b00e tree ebf3af44d253e5328340026e45a9fa9ae3ea1982 parent df2fb7a61f5d40c1191e0fdeb0fc5d6e7969685a author Sanket Patel 1603273316 -0700 committer Sanket Patel 1603273316 -0700 adding file 2 Take a note of parent attribute in the above output. It points to the commit id of the first commit we made. So this proves that they are linked! Additionally you can see the second commit's message in this object. As I said all this magic is enabled by .git folder and the object to which we are looking at also is in that folder. $ ls .git/objects/7f/3b00eaa957815884198e2fdfec29361108d6a9 .git/objects/7f/3b00eaa957815884198e2fdfec29361108d6a9 It is stored in .git/objects/ folder. All the files and changes to them as well are stored in this folder. The Version Control part of Git We already can see two commits (versions) in our git log. One thing a version control tool gives you is ability to browse back and forth in history. For example: some of your users are running an old version of code and they are reporting an issue. In order to debug the issue, you need access to the old code. The one in your current repo is the latest code. In this example, you are working on the second commit (7f3b00e) and someone reported an issue with the code snapshot at commit (df2fb7a). This is how you would get access to the code at any older commit # Current contents, two files present $ ls file1.txt file2.txt # checking out to (an older) commit $ git checkout df2fb7a Note: checking out 'df2fb7a'. You are in 'detached HEAD' state. You can look around, make experimental changes and commit them, and you can discard any commits you make in this state without impacting any branches by performing another checkout. If you want to create a new branch to retain commits you create, you may do so (now or later) by using -b with the checkout command again. Example: git checkout -b HEAD is now at df2fb7a adding file 1 # checking contents, can verify it has old contents $ ls file1.txt So this is how we would get access to old versions/snapshots. All we need is a reference to that snapshot. Upon executing git checkout ... , what git does for you is use the .git folder, see what was the state of things (files and folders) at that version/reference and replace the contents of current directory with those contents. The then-existing content will no longer be present in the local dir (repo) but we can and will still get access to them because they are tracked via git commit and .git folder has them stored/tracked. Reference I mention in the previous section that we need a reference to the version. By default, git repo is made of tree of commits. And each commit has a unique IDs. But the unique ID is not the only thing we can reference commits via. There are multiple ways to reference commits. For example: HEAD is a reference to current commit. Whatever commit your repo is checked out at, HEAD will point to that. HEAD~1 is reference to previous commit. So while checking out previous version in section above, we could have done git checkout HEAD~1 . Similarly, master is also a reference (to a branch). Since git uses tree like structure to store commits, there of course will be branches. And the default branch is called master . Master (or any branch reference) will point to the latest commit in the branch. Even though we have checked out to the previous commit in out repo, master still points to the latest commit. And we can get back to the latest version by checkout at master reference $ git checkout master Previous HEAD position was df2fb7a adding file 1 Switched to branch 'master' # now we will see latest code, with two files $ ls file1.txt file2.txt Note, instead of master in above command, we could have used commit's ID as well. References and The Magic Let's look at the state of things. Two commits, master and HEAD references are pointing to the latest commit $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 The magic? Let's examine these files: $ cat .git/refs/heads/master 7f3b00eaa957815884198e2fdfec29361108d6a9 Viola! Where master is pointing to is stored in a file. Whenever git needs to know where master reference is pointing to, or if git needs to update where master points, it just needs to update the file above. So when you create a new commit, a new commit is created on top of the current commit and the master file is updated with the new commit's ID. Similary, for HEAD reference: $ cat .git/HEAD ref: refs/heads/master We can see HEAD is pointing to a reference called refs/heads/master . So HEAD will point where ever the master points. Little Adventure We discussed how git will update the files as we execute commands. But let's try to do it ourselves, by hand, and see what happens. $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 Now let's change master to point to the previous/first commit. $ echo df2fb7a61f5d40c1191e0fdeb0fc5d6e7969685a > .git/refs/heads/master $ git log --oneline --graph * df2fb7a (HEAD -> master) adding file 1 # RESETTING TO ORIGINAL $ echo 7f3b00eaa957815884198e2fdfec29361108d6a9 > .git/refs/heads/master $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 We just edited the master reference file and now we can see only the first commit in git log. Undoing the change to the file brings the state back to original. Not so much of magic, is it?","title":"Git Basics"},{"location":"level101/git/git-basics/#git","text":"","title":"Git"},{"location":"level101/git/git-basics/#prerequisites","text":"Have Git installed https://git-scm.com/downloads Have taken any git high level tutorial or following LinkedIn learning courses https://www.linkedin.com/learning/git-essential-training-the-basics/ https://www.linkedin.com/learning/git-branches-merges-and-remotes/ The Official Git Docs","title":"Prerequisites"},{"location":"level101/git/git-basics/#what-to-expect-from-this-course","text":"As an engineer in the field of computer science, having knowledge of version control tools becomes almost a requirement. While there are a lot of version control tools that exist today like SVN, Mercurial, etc, Git perhaps is the most used one and this course we will be working with Git. While this course does not start with Git 101 and expects basic knowledge of git as a prerequisite, it will reintroduce the git concepts known by you with details covering what is happening under the hood as you execute various git commands. So that next time you run a git command, you will be able to press enter more confidently!","title":"What to expect from this course"},{"location":"level101/git/git-basics/#what-is-not-covered-under-this-course","text":"Advanced usage and specifics of internal implementation details of Git.","title":"What is not covered under this course"},{"location":"level101/git/git-basics/#course-contents","text":"Git Basics Working with Branches Git with Github Hooks","title":"Course Contents"},{"location":"level101/git/git-basics/#git-basics","text":"Though you might be aware already, let's revisit why we need a version control system. As the project grows and multiple developers start working on it, an efficient method for collaboration is warranted. Git helps the team collaborate easily and also maintains the history of the changes happening with the codebase.","title":"Git Basics"},{"location":"level101/git/git-basics/#creating-a-git-repo","text":"Any folder can be converted into a git repository. After executing the following command, we will see a .git folder within the folder, which makes our folder a git repository. All the magic that git does, .git folder is the enabler for the same. # creating an empty folder and changing current dir to it $ cd /tmp $ mkdir school-of-sre $ cd school-of-sre/ # initialize a git repo $ git init Initialized empty Git repository in /private/tmp/school-of-sre/.git/ As the output says, an empty git repo has been initialized in our folder. Let's take a look at what is there. $ ls .git/ HEAD config description hooks info objects refs There are a bunch of folders and files in the .git folder. As I said, all these enables git to do its magic. We will look into some of these folders and files. But for now, what we have is an empty git repository.","title":"Creating a Git Repo"},{"location":"level101/git/git-basics/#tracking-a-file","text":"Now as you might already know, let us create a new file in our repo (we will refer to the folder as repo now.) And see git status $ echo \"I am file 1\" > file1.txt $ git status On branch master No commits yet Untracked files: (use \"git add ...\" to include in what will be committed) file1.txt nothing added to commit but untracked files present (use \"git add\" to track) The current git status says No commits yet and there is one untracked file. Since we just created the file, git is not tracking that file. We explicitly need to ask git to track files and folders. (also checkout gitignore ) And how we do that is via git add command as suggested in the above output. Then we go ahead and create a commit. $ git add file1.txt $ git status On branch master No commits yet Changes to be committed: (use \"git rm --cached ...\" to unstage) new file: file1.txt $ git commit -m \"adding file 1\" [master (root-commit) df2fb7a] adding file 1 1 file changed, 1 insertion(+) create mode 100644 file1.txt Notice how after adding the file, git status says Changes to be committed: . What it means is whatever is listed there, will be included in the next commit. Then we go ahead and create a commit, with an attached messaged via -m .","title":"Tracking a File"},{"location":"level101/git/git-basics/#more-about-a-commit","text":"Commit is a snapshot of the repo. Whenever a commit is made, a snapshot of the current state of repo (the folder) is taken and saved. Each commit has a unique ID. ( df2fb7a for the commit we made in the previous step). As we keep adding/changing more and more contents and keep making commits, all those snapshots are stored by git. Again, all this magic happens inside the .git folder. This is where all this snapshot or versions are stored in an efficient manner.","title":"More About a Commit"},{"location":"level101/git/git-basics/#adding-more-changes","text":"Let us create one more file and commit the change. It would look the same as the previous commit we made. $ echo \"I am file 2\" > file2.txt $ git add file2.txt $ git commit -m \"adding file 2\" [master 7f3b00e] adding file 2 1 file changed, 1 insertion(+) create mode 100644 file2.txt A new commit with ID 7f3b00e has been created. You can issue git status at any time to see the state of the repository. **IMPORTANT: Note that commit IDs are long string (SHA) but we can refer to a commit by its initial few (8 or more) characters too. We will interchangeably using shorter and longer commit IDs.** Now that we have two commits, let's visualize them: $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 git log , as the name suggests, prints the log of all the git commits. Here you see two additional arguments, --oneline prints the shorter version of the log, ie: the commit message only and not the person who made the commit and when. --graph prints it in graph format. Now at this moment the commits might look like just one in each line but all commits are stored as a tree like data structure internally by git. That means there can be two or more children commits of a given commit. And not just a single line of commits. We will look more into this part when we get to the Branches section. For now this is our commit history: df2fb7a ===> 7f3b00e","title":"Adding More Changes"},{"location":"level101/git/git-basics/#are-commits-really-linked","text":"As I just said, the two commits we just made are linked via tree like data structure and we saw how they are linked. But let's actually verify it. Everything in git is an object. Newly created files are stored as an object. Changes to file are stored as an objects and even commits are objects. To view contents of an object we can use the following command with the object's ID. We will take a look at the contents of the second commit $ git cat-file -p 7f3b00e tree ebf3af44d253e5328340026e45a9fa9ae3ea1982 parent df2fb7a61f5d40c1191e0fdeb0fc5d6e7969685a author Sanket Patel 1603273316 -0700 committer Sanket Patel 1603273316 -0700 adding file 2 Take a note of parent attribute in the above output. It points to the commit id of the first commit we made. So this proves that they are linked! Additionally you can see the second commit's message in this object. As I said all this magic is enabled by .git folder and the object to which we are looking at also is in that folder. $ ls .git/objects/7f/3b00eaa957815884198e2fdfec29361108d6a9 .git/objects/7f/3b00eaa957815884198e2fdfec29361108d6a9 It is stored in .git/objects/ folder. All the files and changes to them as well are stored in this folder.","title":"Are commits really linked?"},{"location":"level101/git/git-basics/#the-version-control-part-of-git","text":"We already can see two commits (versions) in our git log. One thing a version control tool gives you is ability to browse back and forth in history. For example: some of your users are running an old version of code and they are reporting an issue. In order to debug the issue, you need access to the old code. The one in your current repo is the latest code. In this example, you are working on the second commit (7f3b00e) and someone reported an issue with the code snapshot at commit (df2fb7a). This is how you would get access to the code at any older commit # Current contents, two files present $ ls file1.txt file2.txt # checking out to (an older) commit $ git checkout df2fb7a Note: checking out 'df2fb7a'. You are in 'detached HEAD' state. You can look around, make experimental changes and commit them, and you can discard any commits you make in this state without impacting any branches by performing another checkout. If you want to create a new branch to retain commits you create, you may do so (now or later) by using -b with the checkout command again. Example: git checkout -b HEAD is now at df2fb7a adding file 1 # checking contents, can verify it has old contents $ ls file1.txt So this is how we would get access to old versions/snapshots. All we need is a reference to that snapshot. Upon executing git checkout ... , what git does for you is use the .git folder, see what was the state of things (files and folders) at that version/reference and replace the contents of current directory with those contents. The then-existing content will no longer be present in the local dir (repo) but we can and will still get access to them because they are tracked via git commit and .git folder has them stored/tracked.","title":"The Version Control part of Git"},{"location":"level101/git/git-basics/#reference","text":"I mention in the previous section that we need a reference to the version. By default, git repo is made of tree of commits. And each commit has a unique IDs. But the unique ID is not the only thing we can reference commits via. There are multiple ways to reference commits. For example: HEAD is a reference to current commit. Whatever commit your repo is checked out at, HEAD will point to that. HEAD~1 is reference to previous commit. So while checking out previous version in section above, we could have done git checkout HEAD~1 . Similarly, master is also a reference (to a branch). Since git uses tree like structure to store commits, there of course will be branches. And the default branch is called master . Master (or any branch reference) will point to the latest commit in the branch. Even though we have checked out to the previous commit in out repo, master still points to the latest commit. And we can get back to the latest version by checkout at master reference $ git checkout master Previous HEAD position was df2fb7a adding file 1 Switched to branch 'master' # now we will see latest code, with two files $ ls file1.txt file2.txt Note, instead of master in above command, we could have used commit's ID as well.","title":"Reference"},{"location":"level101/git/git-basics/#references-and-the-magic","text":"Let's look at the state of things. Two commits, master and HEAD references are pointing to the latest commit $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 The magic? Let's examine these files: $ cat .git/refs/heads/master 7f3b00eaa957815884198e2fdfec29361108d6a9 Viola! Where master is pointing to is stored in a file. Whenever git needs to know where master reference is pointing to, or if git needs to update where master points, it just needs to update the file above. So when you create a new commit, a new commit is created on top of the current commit and the master file is updated with the new commit's ID. Similary, for HEAD reference: $ cat .git/HEAD ref: refs/heads/master We can see HEAD is pointing to a reference called refs/heads/master . So HEAD will point where ever the master points.","title":"References and The Magic"},{"location":"level101/git/git-basics/#little-adventure","text":"We discussed how git will update the files as we execute commands. But let's try to do it ourselves, by hand, and see what happens. $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 Now let's change master to point to the previous/first commit. $ echo df2fb7a61f5d40c1191e0fdeb0fc5d6e7969685a > .git/refs/heads/master $ git log --oneline --graph * df2fb7a (HEAD -> master) adding file 1 # RESETTING TO ORIGINAL $ echo 7f3b00eaa957815884198e2fdfec29361108d6a9 > .git/refs/heads/master $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 We just edited the master reference file and now we can see only the first commit in git log. Undoing the change to the file brings the state back to original. Not so much of magic, is it?","title":"Little Adventure"},{"location":"level101/git/github-hooks/","text":"Git with Github Till now all the operations we did were in our local repo while git also helps us in a collaborative environment. GitHub is one place on the internet where you can centrally host your git repos and collaborate with other developers. Most of the workflow will remain the same as we discussed, with addition of couple of things: Pull: to pull latest changes from github (the central) repo Push: to push your changes to github repo so that it's available to all people GitHub has written nice guides and tutorials about this and you can refer them here: GitHub Hello World Git Handbook Hooks Git has another nice feature called hooks. Hooks are basically scripts which will be called when a certain event happens. Here is where hooks are located: $ ls .git/hooks/ applypatch-msg.sample fsmonitor-watchman.sample pre-applypatch.sample pre-push.sample pre-receive.sample update.sample commit-msg.sample post-update.sample pre-commit.sample pre-rebase.sample prepare-commit-msg.sample Names are self explanatory. These hooks are useful when you want to do certain things when a certain event happens. If you want to run tests before pushing code, you would want to setup pre-push hooks. Let's try to create a pre commit hook. $ echo \"echo this is from pre commit hook\" > .git/hooks/pre-commit $ chmod +x .git/hooks/pre-commit We basically create a file called pre-commit in hooks folder and make it executable. Now if we make a commit, we should see the message getting printed. $ echo \"sample file\" > sample.txt $ git add sample.txt $ git commit -m \"adding sample file\" this is from pre commit hook # <===== THE MESSAGE FROM HOOK EXECUTION [master 9894e05] adding sample file 1 file changed, 1 insertion(+) create mode 100644 sample.txt","title":"Github and Hooks"},{"location":"level101/git/github-hooks/#git-with-github","text":"Till now all the operations we did were in our local repo while git also helps us in a collaborative environment. GitHub is one place on the internet where you can centrally host your git repos and collaborate with other developers. Most of the workflow will remain the same as we discussed, with addition of couple of things: Pull: to pull latest changes from github (the central) repo Push: to push your changes to github repo so that it's available to all people GitHub has written nice guides and tutorials about this and you can refer them here: GitHub Hello World Git Handbook","title":"Git with Github"},{"location":"level101/git/github-hooks/#hooks","text":"Git has another nice feature called hooks. Hooks are basically scripts which will be called when a certain event happens. Here is where hooks are located: $ ls .git/hooks/ applypatch-msg.sample fsmonitor-watchman.sample pre-applypatch.sample pre-push.sample pre-receive.sample update.sample commit-msg.sample post-update.sample pre-commit.sample pre-rebase.sample prepare-commit-msg.sample Names are self explanatory. These hooks are useful when you want to do certain things when a certain event happens. If you want to run tests before pushing code, you would want to setup pre-push hooks. Let's try to create a pre commit hook. $ echo \"echo this is from pre commit hook\" > .git/hooks/pre-commit $ chmod +x .git/hooks/pre-commit We basically create a file called pre-commit in hooks folder and make it executable. Now if we make a commit, we should see the message getting printed. $ echo \"sample file\" > sample.txt $ git add sample.txt $ git commit -m \"adding sample file\" this is from pre commit hook # <===== THE MESSAGE FROM HOOK EXECUTION [master 9894e05] adding sample file 1 file changed, 1 insertion(+) create mode 100644 sample.txt","title":"Hooks"},{"location":"level101/linux_basics/command_line_basics/","text":"Command Line Basics Lab Environment Setup One can use an online bash interpreter to run all the commands that are provided as examples in this course. This will also help you in getting a hands-on experience of various linux commands. REPL is one of the popular online bash interpreters for running linux commands. We will be using it for running all the commands mentioned in this course. What is a Command A command is a program that tells the operating system to perform specific work. Programs are stored as files in linux. Therefore, a command is also a file which is stored somewhere on the disk. Commands may also take additional arguments as input from the user. These arguments are called command line arguments. Knowing how to use the commands is important and there are many ways to get help in Linux, especially for commands. Almost every command will have some form of documentation, most commands will have a command-line argument -h or --help that will display a reasonable amount of documentation. But the most popular documentation system in Linux is called man pages - short for manual pages. Using --help to show the documentation for ls command. File System Organization The linux file system has a hierarchical (or tree-like) structure with its highest level directory called root ( denoted by / ). Directories present inside the root directory stores file related to the system. These directories in turn can either store system files or application files or user related files. bin | The executable program of most commonly used commands reside in bin directory sbin | This directory contains programs used for system administration. home | This directory contains user related files and directories. lib | This directory contains all the library files etc | This directory contains all the system configuration files proc | This directory contains files related to the running processes on the system dev | This directory contains files related to devices on the system mnt | This directory contains files related to mounted devices on the system tmp | This directory is used to store temporary files on the system usr | This directory is used to store application programs on the system Commands for Navigating the File System There are three basic commands which are used frequently to navigate the file system: ls pwd cd We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. pwd (print working directory) At any given moment of time, we will be standing in a certain directory. To get the name of the directory in which we are standing, we can use the pwd command in linux. We will now use the cd command to move to a different directory and then print the working directory. cd (change directory) The cd command can be used to change the working directory. Using the command, you can move from one directory to another. In the below example, we are initially in the root directory. we have then used the cd command to change the directory. ls (list files and directories)** The ls command is used to list the contents of a directory. It will list down all the files and folders present in the given directory. If we just type ls in the shell, it will list all the files and directories present in the current directory. We can also provide the directory name as argument to ls command. It will then list all the files and directories inside the given directory. Commands for Manipulating Files There are five basic commands which are used frequently to manipulate files: touch mkdir cp mv rm We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. touch (create new file) The touch command can be used to create an empty new file. This command is very useful for many other purposes but we will discuss the simplest use case of creating a new file. General syntax of using touch command touch mkdir (create new directories) The mkdir command is used to create directories.You can use ls command to verify that the new directory is created. General syntax of using mkdir command mkdir rm (delete files and directories) The rm command can be used to delete files and directories. It is very important to note that this command permanently deletes the files and directories. It's almost impossible to recover these files and directories once you have executed rm command on them successfully. Do run this command with care. General syntax of using rm command: rm Let's try to understand the rm command with an example. We will try to delete the file and directory we created using touch and mkdir command respectively. cp (copy files and directories) The cp command is used to copy files and directories from one location to another. Do note that the cp command doesn't do any change to the original files or directories. The original files or directories and their copy both co-exist after running cp command successfully. General syntax of using cp command: cp We are currently in the '/home/runner' directory. We will use the mkdir command to create a new directory named \"test_directory\". We will now try to copy the \"_test_runner.py\" file to the directory we created just now. Do note that nothing happened to the original \"_test_runner.py\" file. It's still there in the current directory. A new copy of it got created inside the \"test_directory\". We can also use the cp command to copy the whole directory from one location to another. Let's try to understand this with an example. We again used the mkdir command to create a new directory called \"another_directory\". We then used the cp command along with an additional argument '-r' to copy the \"test_directory\". mv (move files and directories) The mv command can either be used to move files or directories from one location to another or it can be used to rename files or directories. Do note that moving files and copying them are very different. When you move the files or directories, the original copy is lost. General syntax of using mv command: mv In this example, we will use the mv command to move the \"_test_runner.py\" file to \"test_directory\". In this case, this file already exists in \"test_directory\". The mv command will just replace it. Do note that the original file doesn't exist in the current directory after mv command ran successfully. We can also use the mv command to move a directory from one location to another. In this case, we do not need to use the '-r' flag that we did while using the cp command. Do note that the original directory will not exist if we use mv command. One of the important uses of the mv command is to rename files and directories. Let's see how we can use this command for renaming. We have first changed our location to \"test_directory\". We then use the mv command to rename the \"\"_test_runner.py\" file to \"test.py\". Commands for Viewing Files There are five basic commands which are used frequently to view the files: cat head tail more less We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. We will create a new file called \"numbers.txt\" and insert numbers from 1 to 100 in this file. Each number will be in a separate line. Do not worry about the above command now. It's an advanced command which is used to generate numbers. We have then used a redirection operator to push these numbers to the file. We will be discussing I/O redirection in the later sections. cat The most simplest use of cat command is to print the contents of the file on your output screen. This command is very useful and can be used for many other purposes. We will study about other use cases later. You can try to run the above command and you will see numbers being printed from 1 to 100 on your screen. You will need to scroll up to view all the numbers. head The head command displays the first 10 lines of the file by default. We can include additional arguments to display as many lines as we want from the top. In this example, we are only able to see the first 10 lines from the file when we use the head command. By default, head command will only display the first 10 lines. If we want to specify the number of lines we want to see from start, use the '-n' argument to provide the input. tail The tail command displays the last 10 lines of the file by default. We can include additional arguments to display as many lines as we want from the end of the file. By default, the tail command will only display the last 10 lines. If we want to specify the number of lines we want to see from the end, use '-n' argument to provide the input. In this example, we are only able to see the last 5 lines from the file when we use the tail command with explicit -n option. more More command displays the contents of a file or a command output, displaying one screen at a time in case the file is large (Eg: log files). It also allows forward navigation and limited backward navigation in the file. More command displays as much as can fit on the current screen and waits for user input to advance. Forward navigation can be done by pressing Enter, which advances the output by one line and Space, which advances the output by one screen. less Less command is an improved version of more. It displays the contents of a file or a command output, one page at a time. It allows backward navigation as well as forward navigation in the file and also has search options. We can use arrow keys for advancing backward or forward by one line. For moving forward by one page, press Space and for moving backward by one page, press b on your keyboard. You can go to the beginning and the end of a file instantly. Echo Command in Linux The echo command is one of the simplest commands that is used in the shell. This command is equivalent to what we have in other programming languages. The echo command prints the given input string on the screen. Text Processing Commands In the previous section, we learned how to view the content of a file. In many cases, we will be interested in performing the below operations: Print only the lines which contain a particular word(s) Replace a particular word with another word in a file Sort the lines in a particular order There are three basic commands which are used frequently to process texts: grep sed sort We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. We will create a new file called \"numbers.txt\" and insert numbers from 1 to 10 in this file. Each number will be in a separate line. grep The grep command in its simplest form can be used to search particular words in a text file. It will display all the lines in a file that contains a particular input. The word we want to search is provided as an input to the grep command. General syntax of using grep command: grep In this example, we are trying to search for a string \"1\" in this file. The grep command outputs the lines where it found this string. sed The sed command in its simplest form can be used to replace a text in a file. General syntax of using the sed command for replacement: sed 's///' Let's try to replace each occurrence of \"1\" in the file with \"3\" using sed command. The content of the file will not change in the above example. To do so, we have to use an extra argument '-i' so that the changes are reflected back in the file. sort The sort command can be used to sort the input provided to it as an argument. By default, it will sort in increasing order. Let's first see the content of the file before trying to sort it. Now, we will try to sort the file using the sort command. The sort command sorts the content in lexicographical order. The content of the file will not change in the above example. I/O Redirection Each open file gets assigned a file descriptor. A file descriptor is an unique identifier for open files in the system. There are always three default files open, stdin (the keyboard), stdout (the screen), and stderr (error messages output to the screen). These files can be redirected. Everything is a file in linux - https://unix.stackexchange.com/questions/225537/everything-is-a-file Till now, we have displayed all the output on the screen which is the standard output. We can use some special operators to redirect the output of the command to files or even to the input of other commands. I/O redirection is a very powerful feature. In the below example, we have used the '>' operator to redirect the output of ls command to output.txt file. In the below example, we have redirected the output from echo command to a file. We can also redirect the output of a command as an input to another command. This is possible with the help of pipes. In the below example, we have passed the output of cat command as an input to grep command using pipe(|) operator. In the below example, we have passed the output of sort command as an input to uniq command using pipe(|) operator. The uniq command only prints the unique numbers from the input. I/O redirection - https://tldp.org/LDP/abs/html/io-redirection.html","title":"Command Line Basics"},{"location":"level101/linux_basics/command_line_basics/#command-line-basics","text":"","title":"Command Line Basics"},{"location":"level101/linux_basics/command_line_basics/#lab-environment-setup","text":"One can use an online bash interpreter to run all the commands that are provided as examples in this course. This will also help you in getting a hands-on experience of various linux commands. REPL is one of the popular online bash interpreters for running linux commands. We will be using it for running all the commands mentioned in this course.","title":"Lab Environment Setup"},{"location":"level101/linux_basics/command_line_basics/#what-is-a-command","text":"A command is a program that tells the operating system to perform specific work. Programs are stored as files in linux. Therefore, a command is also a file which is stored somewhere on the disk. Commands may also take additional arguments as input from the user. These arguments are called command line arguments. Knowing how to use the commands is important and there are many ways to get help in Linux, especially for commands. Almost every command will have some form of documentation, most commands will have a command-line argument -h or --help that will display a reasonable amount of documentation. But the most popular documentation system in Linux is called man pages - short for manual pages. Using --help to show the documentation for ls command.","title":"What is a Command"},{"location":"level101/linux_basics/command_line_basics/#file-system-organization","text":"The linux file system has a hierarchical (or tree-like) structure with its highest level directory called root ( denoted by / ). Directories present inside the root directory stores file related to the system. These directories in turn can either store system files or application files or user related files. bin | The executable program of most commonly used commands reside in bin directory sbin | This directory contains programs used for system administration. home | This directory contains user related files and directories. lib | This directory contains all the library files etc | This directory contains all the system configuration files proc | This directory contains files related to the running processes on the system dev | This directory contains files related to devices on the system mnt | This directory contains files related to mounted devices on the system tmp | This directory is used to store temporary files on the system usr | This directory is used to store application programs on the system","title":"File System Organization"},{"location":"level101/linux_basics/command_line_basics/#commands-for-navigating-the-file-system","text":"There are three basic commands which are used frequently to navigate the file system: ls pwd cd We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell.","title":"Commands for Navigating the File System"},{"location":"level101/linux_basics/command_line_basics/#pwd-print-working-directory","text":"At any given moment of time, we will be standing in a certain directory. To get the name of the directory in which we are standing, we can use the pwd command in linux. We will now use the cd command to move to a different directory and then print the working directory.","title":"pwd (print working directory)"},{"location":"level101/linux_basics/command_line_basics/#cd-change-directory","text":"The cd command can be used to change the working directory. Using the command, you can move from one directory to another. In the below example, we are initially in the root directory. we have then used the cd command to change the directory.","title":"cd (change directory)"},{"location":"level101/linux_basics/command_line_basics/#ls-list-files-and-directories","text":"The ls command is used to list the contents of a directory. It will list down all the files and folders present in the given directory. If we just type ls in the shell, it will list all the files and directories present in the current directory. We can also provide the directory name as argument to ls command. It will then list all the files and directories inside the given directory.","title":"ls (list files and directories)**"},{"location":"level101/linux_basics/command_line_basics/#commands-for-manipulating-files","text":"There are five basic commands which are used frequently to manipulate files: touch mkdir cp mv rm We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell.","title":"Commands for Manipulating Files"},{"location":"level101/linux_basics/command_line_basics/#touch-create-new-file","text":"The touch command can be used to create an empty new file. This command is very useful for many other purposes but we will discuss the simplest use case of creating a new file. General syntax of using touch command touch ","title":"touch (create new file)"},{"location":"level101/linux_basics/command_line_basics/#mkdir-create-new-directories","text":"The mkdir command is used to create directories.You can use ls command to verify that the new directory is created. General syntax of using mkdir command mkdir ","title":"mkdir (create new directories)"},{"location":"level101/linux_basics/command_line_basics/#rm-delete-files-and-directories","text":"The rm command can be used to delete files and directories. It is very important to note that this command permanently deletes the files and directories. It's almost impossible to recover these files and directories once you have executed rm command on them successfully. Do run this command with care. General syntax of using rm command: rm Let's try to understand the rm command with an example. We will try to delete the file and directory we created using touch and mkdir command respectively.","title":"rm (delete files and directories)"},{"location":"level101/linux_basics/command_line_basics/#cp-copy-files-and-directories","text":"The cp command is used to copy files and directories from one location to another. Do note that the cp command doesn't do any change to the original files or directories. The original files or directories and their copy both co-exist after running cp command successfully. General syntax of using cp command: cp We are currently in the '/home/runner' directory. We will use the mkdir command to create a new directory named \"test_directory\". We will now try to copy the \"_test_runner.py\" file to the directory we created just now. Do note that nothing happened to the original \"_test_runner.py\" file. It's still there in the current directory. A new copy of it got created inside the \"test_directory\". We can also use the cp command to copy the whole directory from one location to another. Let's try to understand this with an example. We again used the mkdir command to create a new directory called \"another_directory\". We then used the cp command along with an additional argument '-r' to copy the \"test_directory\". mv (move files and directories) The mv command can either be used to move files or directories from one location to another or it can be used to rename files or directories. Do note that moving files and copying them are very different. When you move the files or directories, the original copy is lost. General syntax of using mv command: mv In this example, we will use the mv command to move the \"_test_runner.py\" file to \"test_directory\". In this case, this file already exists in \"test_directory\". The mv command will just replace it. Do note that the original file doesn't exist in the current directory after mv command ran successfully. We can also use the mv command to move a directory from one location to another. In this case, we do not need to use the '-r' flag that we did while using the cp command. Do note that the original directory will not exist if we use mv command. One of the important uses of the mv command is to rename files and directories. Let's see how we can use this command for renaming. We have first changed our location to \"test_directory\". We then use the mv command to rename the \"\"_test_runner.py\" file to \"test.py\".","title":"cp (copy files and directories)"},{"location":"level101/linux_basics/command_line_basics/#commands-for-viewing-files","text":"There are five basic commands which are used frequently to view the files: cat head tail more less We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. We will create a new file called \"numbers.txt\" and insert numbers from 1 to 100 in this file. Each number will be in a separate line. Do not worry about the above command now. It's an advanced command which is used to generate numbers. We have then used a redirection operator to push these numbers to the file. We will be discussing I/O redirection in the later sections.","title":"Commands for Viewing Files"},{"location":"level101/linux_basics/command_line_basics/#cat","text":"The most simplest use of cat command is to print the contents of the file on your output screen. This command is very useful and can be used for many other purposes. We will study about other use cases later. You can try to run the above command and you will see numbers being printed from 1 to 100 on your screen. You will need to scroll up to view all the numbers.","title":"cat"},{"location":"level101/linux_basics/command_line_basics/#head","text":"The head command displays the first 10 lines of the file by default. We can include additional arguments to display as many lines as we want from the top. In this example, we are only able to see the first 10 lines from the file when we use the head command. By default, head command will only display the first 10 lines. If we want to specify the number of lines we want to see from start, use the '-n' argument to provide the input.","title":"head"},{"location":"level101/linux_basics/command_line_basics/#tail","text":"The tail command displays the last 10 lines of the file by default. We can include additional arguments to display as many lines as we want from the end of the file. By default, the tail command will only display the last 10 lines. If we want to specify the number of lines we want to see from the end, use '-n' argument to provide the input. In this example, we are only able to see the last 5 lines from the file when we use the tail command with explicit -n option.","title":"tail"},{"location":"level101/linux_basics/command_line_basics/#more","text":"More command displays the contents of a file or a command output, displaying one screen at a time in case the file is large (Eg: log files). It also allows forward navigation and limited backward navigation in the file. More command displays as much as can fit on the current screen and waits for user input to advance. Forward navigation can be done by pressing Enter, which advances the output by one line and Space, which advances the output by one screen.","title":"more"},{"location":"level101/linux_basics/command_line_basics/#less","text":"Less command is an improved version of more. It displays the contents of a file or a command output, one page at a time. It allows backward navigation as well as forward navigation in the file and also has search options. We can use arrow keys for advancing backward or forward by one line. For moving forward by one page, press Space and for moving backward by one page, press b on your keyboard. You can go to the beginning and the end of a file instantly.","title":"less"},{"location":"level101/linux_basics/command_line_basics/#echo-command-in-linux","text":"The echo command is one of the simplest commands that is used in the shell. This command is equivalent to what we have in other programming languages. The echo command prints the given input string on the screen.","title":"Echo Command in Linux"},{"location":"level101/linux_basics/command_line_basics/#text-processing-commands","text":"In the previous section, we learned how to view the content of a file. In many cases, we will be interested in performing the below operations: Print only the lines which contain a particular word(s) Replace a particular word with another word in a file Sort the lines in a particular order There are three basic commands which are used frequently to process texts: grep sed sort We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. We will create a new file called \"numbers.txt\" and insert numbers from 1 to 10 in this file. Each number will be in a separate line.","title":"Text Processing Commands"},{"location":"level101/linux_basics/command_line_basics/#grep","text":"The grep command in its simplest form can be used to search particular words in a text file. It will display all the lines in a file that contains a particular input. The word we want to search is provided as an input to the grep command. General syntax of using grep command: grep In this example, we are trying to search for a string \"1\" in this file. The grep command outputs the lines where it found this string.","title":"grep"},{"location":"level101/linux_basics/command_line_basics/#sed","text":"The sed command in its simplest form can be used to replace a text in a file. General syntax of using the sed command for replacement: sed 's///' Let's try to replace each occurrence of \"1\" in the file with \"3\" using sed command. The content of the file will not change in the above example. To do so, we have to use an extra argument '-i' so that the changes are reflected back in the file.","title":"sed"},{"location":"level101/linux_basics/command_line_basics/#sort","text":"The sort command can be used to sort the input provided to it as an argument. By default, it will sort in increasing order. Let's first see the content of the file before trying to sort it. Now, we will try to sort the file using the sort command. The sort command sorts the content in lexicographical order. The content of the file will not change in the above example.","title":"sort"},{"location":"level101/linux_basics/command_line_basics/#io-redirection","text":"Each open file gets assigned a file descriptor. A file descriptor is an unique identifier for open files in the system. There are always three default files open, stdin (the keyboard), stdout (the screen), and stderr (error messages output to the screen). These files can be redirected. Everything is a file in linux - https://unix.stackexchange.com/questions/225537/everything-is-a-file Till now, we have displayed all the output on the screen which is the standard output. We can use some special operators to redirect the output of the command to files or even to the input of other commands. I/O redirection is a very powerful feature. In the below example, we have used the '>' operator to redirect the output of ls command to output.txt file. In the below example, we have redirected the output from echo command to a file. We can also redirect the output of a command as an input to another command. This is possible with the help of pipes. In the below example, we have passed the output of cat command as an input to grep command using pipe(|) operator. In the below example, we have passed the output of sort command as an input to uniq command using pipe(|) operator. The uniq command only prints the unique numbers from the input. I/O redirection - https://tldp.org/LDP/abs/html/io-redirection.html","title":"I/O Redirection"},{"location":"level101/linux_basics/conclusion/","text":"Conclusion We have covered the basics of Linux operating systems and basic commands used in linux. We have also covered the Linux server administration commands. We hope that this course will make it easier for you to operate on the command line. Applications in SRE Role As a SRE, you will be required to perform some general tasks on these Linux servers. You will also be using the command line when you are troubleshooting issues. Moving from one location to another in the filesystem will require the help of ls , pwd and cd commands. You may need to search some specific information in the log files. grep command would be very useful here. I/O redirection will become handy if you want to store the output in a file or pass it as an input to another command. tail command is very useful to view the latest data in the log file. Different users will have different permissions depending on their roles. We will also not want everyone in the company to access our servers for security reasons. Users permissions can be restricted with chown , chmod and chgrp commands. ssh is one of the most frequently used commands for a SRE. Logging into servers and troubleshooting along with performing basic administration tasks will only be possible if we are able to login into the server. What if we want to run an apache server or nginx on a server? We will first install it using the package manager. Package management commands become important here. Managing services on servers is another critical responsibility of a SRE. Systemd related commands can help in troubleshooting issues. If a service goes down, we can start it using systemctl start command. We can also stop a service in case it is not needed. Monitoring is another core responsibility of a SRE. Memory and CPU are two important system level metrics which should be monitored. Commands like top and free are quite helpful here. If a service is throwing an error, how do we find out the root cause of the error ? We will certainly need to check logs to find out the whole stack trace of the error. The log file will also tell us the number of times the error has occurred along with time when it started. Useful Courses and tutorials Edx basic linux commands course Edx Red Hat Enterprise Linux Course https://linuxcommand.org/lc3_learning_the_shell.php","title":"Conclusion"},{"location":"level101/linux_basics/conclusion/#conclusion","text":"We have covered the basics of Linux operating systems and basic commands used in linux. We have also covered the Linux server administration commands. We hope that this course will make it easier for you to operate on the command line.","title":"Conclusion"},{"location":"level101/linux_basics/conclusion/#applications-in-sre-role","text":"As a SRE, you will be required to perform some general tasks on these Linux servers. You will also be using the command line when you are troubleshooting issues. Moving from one location to another in the filesystem will require the help of ls , pwd and cd commands. You may need to search some specific information in the log files. grep command would be very useful here. I/O redirection will become handy if you want to store the output in a file or pass it as an input to another command. tail command is very useful to view the latest data in the log file. Different users will have different permissions depending on their roles. We will also not want everyone in the company to access our servers for security reasons. Users permissions can be restricted with chown , chmod and chgrp commands. ssh is one of the most frequently used commands for a SRE. Logging into servers and troubleshooting along with performing basic administration tasks will only be possible if we are able to login into the server. What if we want to run an apache server or nginx on a server? We will first install it using the package manager. Package management commands become important here. Managing services on servers is another critical responsibility of a SRE. Systemd related commands can help in troubleshooting issues. If a service goes down, we can start it using systemctl start command. We can also stop a service in case it is not needed. Monitoring is another core responsibility of a SRE. Memory and CPU are two important system level metrics which should be monitored. Commands like top and free are quite helpful here. If a service is throwing an error, how do we find out the root cause of the error ? We will certainly need to check logs to find out the whole stack trace of the error. The log file will also tell us the number of times the error has occurred along with time when it started.","title":"Applications in SRE Role"},{"location":"level101/linux_basics/conclusion/#useful-courses-and-tutorials","text":"Edx basic linux commands course Edx Red Hat Enterprise Linux Course https://linuxcommand.org/lc3_learning_the_shell.php","title":"Useful Courses and tutorials"},{"location":"level101/linux_basics/intro/","text":"Linux Basics Introduction Prerequisites Should be comfortable in using any operating systems like Windows, Linux or Mac Expected to have fundamental knowledge of operating systems What to expect from this course This course is divided into three parts. In the first part, we cover the fundamentals of Linux operating systems. We will talk about Linux architecture, Linux distributions and uses of Linux operating systems. We will also talk about the difference between GUI and CLI. In the second part, we cover some basic commands used in Linux. We will focus on commands used for navigating the file system, viewing and manipulating files, I/O redirection etc. In the third part, we cover Linux system administration. This includes day to day tasks performed by Linux admins, like managing users/groups, managing file permissions, monitoring system performance, log files etc. In the second and third part, we will be taking examples to understand the concepts. What is not covered under this course We are not covering advanced Linux commands and bash scripting in this course. We will also not be covering Linux internals. Course Contents The following topics has been covered in this course: Introduction to Linux What are Linux Operating Systems What are popular Linux distributions Uses of Linux Operating Systems Linux Architecture Graphical user interface (GUI) vs Command line interface (CLI) Command Line Basics Lab Environment Setup What is a Command File System Organization Navigating File System Manipulating Files Viewing Files Echo Command Text Processing Commands I/O Redirection Linux system administration Lab Environment Setup User/Groups management Becoming a Superuser File Permissions SSH Command Package Management Process Management Memory Management Daemons and Systemd Logs Conclusion Applications in SRE Role Useful Courses and tutorials What are Linux operating systems Most of us are familiar with the Windows operating system used in more than 75% of the personal computers. The Windows operating systems are based on Windows NT kernel. A kernel is the most important part of an operating system - it performs important functions like process management, memory management, filesystem management etc. Linux operating systems are based on the Linux kernel. A Linux based operating system will consist of Linux kernel, GUI/CLI, system libraries and system utilities. The Linux kernel was independently developed and released by Linus Torvalds. The Linux kernel is free and open-source - https://github.com/torvalds/linux Linux is a kernel and and not a complete operating system. Linux kernel is combined with GNU system to make a complete operating system. Therefore, linux based operating systems are also called as GNU/Linux systems. GNU is an extensive collection of free softwares like compiler, debugger, C library etc. Linux and the GNU System History of Linux - https://en.wikipedia.org/wiki/History_of_Linux What are popular Linux distributions A Linux distribution(distro) is an operating system based on the Linux kernel and a package management system. A package management system consists of tools that help in installing, upgrading, configuring and removing softwares on the operating system. Software are usually adopted to a distribution and are packaged in a distro specific format. These packages are available through a distro specific repository. Packages are installed and managed in the operating system by a package manager. List of popular Linux distributions: Fedora Ubuntu Debian Centos Red Hat Enterprise Linux Suse Arch Linux Packaging systems Distributions Package manager Debian style (.deb) Debian, Ubuntu APT Red Hat style (.rpm) Fedora, CentOS, Red Hat Enterprise Linux YUM Linux Architecture The Linux kernel is monolithic in nature. System calls are used to interact with the Linux kernel space. Kernel code can only be executed in the kernel mode. Non-kernel code is executed in the user mode. Device drivers are used to communicate with the hardware devices. Uses of Linux Operating Systems Operating system based on Linux kernel are widely used in: Personal computers Servers Mobile phones - Android is based on Linux operating system Embedded devices - watches, televisions, traffic lights etc Satellites Network devices - routers, switches etc. Graphical user interface (GUI) vs Command line interface (CLI) A user interacts with a computer with the help of user interfaces. The user interface can be either GUI or CLI. Graphical user interface allows a user to interact with the computer using graphics such as icons and images. When a user clicks on an icon to open an application on a computer, he or she is actually using the GUI. It's easy to perform tasks using GUI. Command line interface allows a user to interact with the computer using commands. A user types the command in a terminal and the system helps in executing these commands. A new user with experience on GUI may find it difficult to interact with CLI as he/she needs to be aware of the commands to perform a particular operation. Shell vs Terminal Shell is a program that takes commands from the users and gives them to the operating system for processing. Shell is an example of a CLI (command line interface). Bash is one of the most popular shell programs available on Linux servers. Other popular shell programs are zsh, ksh and tcsh. Terminal is a program that opens a window and lets you interact with the shell. Some popular examples of terminals are gnome-terminal, xterm, konsole etc. Linux users do use the terms shell, terminal, prompt, console etc. interchangeably. In simple terms, these all refer to a way of taking commands from the user.","title":"Introduction"},{"location":"level101/linux_basics/intro/#linux-basics","text":"","title":"Linux Basics"},{"location":"level101/linux_basics/intro/#introduction","text":"","title":"Introduction"},{"location":"level101/linux_basics/intro/#prerequisites","text":"Should be comfortable in using any operating systems like Windows, Linux or Mac Expected to have fundamental knowledge of operating systems","title":"Prerequisites"},{"location":"level101/linux_basics/intro/#what-to-expect-from-this-course","text":"This course is divided into three parts. In the first part, we cover the fundamentals of Linux operating systems. We will talk about Linux architecture, Linux distributions and uses of Linux operating systems. We will also talk about the difference between GUI and CLI. In the second part, we cover some basic commands used in Linux. We will focus on commands used for navigating the file system, viewing and manipulating files, I/O redirection etc. In the third part, we cover Linux system administration. This includes day to day tasks performed by Linux admins, like managing users/groups, managing file permissions, monitoring system performance, log files etc. In the second and third part, we will be taking examples to understand the concepts.","title":"What to expect from this course"},{"location":"level101/linux_basics/intro/#what-is-not-covered-under-this-course","text":"We are not covering advanced Linux commands and bash scripting in this course. We will also not be covering Linux internals.","title":"What is not covered under this course"},{"location":"level101/linux_basics/intro/#course-contents","text":"The following topics has been covered in this course: Introduction to Linux What are Linux Operating Systems What are popular Linux distributions Uses of Linux Operating Systems Linux Architecture Graphical user interface (GUI) vs Command line interface (CLI) Command Line Basics Lab Environment Setup What is a Command File System Organization Navigating File System Manipulating Files Viewing Files Echo Command Text Processing Commands I/O Redirection Linux system administration Lab Environment Setup User/Groups management Becoming a Superuser File Permissions SSH Command Package Management Process Management Memory Management Daemons and Systemd Logs Conclusion Applications in SRE Role Useful Courses and tutorials","title":"Course Contents"},{"location":"level101/linux_basics/intro/#what-are-linux-operating-systems","text":"Most of us are familiar with the Windows operating system used in more than 75% of the personal computers. The Windows operating systems are based on Windows NT kernel. A kernel is the most important part of an operating system - it performs important functions like process management, memory management, filesystem management etc. Linux operating systems are based on the Linux kernel. A Linux based operating system will consist of Linux kernel, GUI/CLI, system libraries and system utilities. The Linux kernel was independently developed and released by Linus Torvalds. The Linux kernel is free and open-source - https://github.com/torvalds/linux Linux is a kernel and and not a complete operating system. Linux kernel is combined with GNU system to make a complete operating system. Therefore, linux based operating systems are also called as GNU/Linux systems. GNU is an extensive collection of free softwares like compiler, debugger, C library etc. Linux and the GNU System History of Linux - https://en.wikipedia.org/wiki/History_of_Linux","title":"What are Linux operating systems"},{"location":"level101/linux_basics/intro/#what-are-popular-linux-distributions","text":"A Linux distribution(distro) is an operating system based on the Linux kernel and a package management system. A package management system consists of tools that help in installing, upgrading, configuring and removing softwares on the operating system. Software are usually adopted to a distribution and are packaged in a distro specific format. These packages are available through a distro specific repository. Packages are installed and managed in the operating system by a package manager. List of popular Linux distributions: Fedora Ubuntu Debian Centos Red Hat Enterprise Linux Suse Arch Linux Packaging systems Distributions Package manager Debian style (.deb) Debian, Ubuntu APT Red Hat style (.rpm) Fedora, CentOS, Red Hat Enterprise Linux YUM","title":"What are popular Linux distributions"},{"location":"level101/linux_basics/intro/#linux-architecture","text":"The Linux kernel is monolithic in nature. System calls are used to interact with the Linux kernel space. Kernel code can only be executed in the kernel mode. Non-kernel code is executed in the user mode. Device drivers are used to communicate with the hardware devices.","title":"Linux Architecture"},{"location":"level101/linux_basics/intro/#uses-of-linux-operating-systems","text":"Operating system based on Linux kernel are widely used in: Personal computers Servers Mobile phones - Android is based on Linux operating system Embedded devices - watches, televisions, traffic lights etc Satellites Network devices - routers, switches etc.","title":"Uses of Linux Operating Systems"},{"location":"level101/linux_basics/intro/#graphical-user-interface-gui-vs-command-line-interface-cli","text":"A user interacts with a computer with the help of user interfaces. The user interface can be either GUI or CLI. Graphical user interface allows a user to interact with the computer using graphics such as icons and images. When a user clicks on an icon to open an application on a computer, he or she is actually using the GUI. It's easy to perform tasks using GUI. Command line interface allows a user to interact with the computer using commands. A user types the command in a terminal and the system helps in executing these commands. A new user with experience on GUI may find it difficult to interact with CLI as he/she needs to be aware of the commands to perform a particular operation.","title":"Graphical user interface (GUI) vs Command line interface (CLI)"},{"location":"level101/linux_basics/intro/#shell-vs-terminal","text":"Shell is a program that takes commands from the users and gives them to the operating system for processing. Shell is an example of a CLI (command line interface). Bash is one of the most popular shell programs available on Linux servers. Other popular shell programs are zsh, ksh and tcsh. Terminal is a program that opens a window and lets you interact with the shell. Some popular examples of terminals are gnome-terminal, xterm, konsole etc. Linux users do use the terms shell, terminal, prompt, console etc. interchangeably. In simple terms, these all refer to a way of taking commands from the user.","title":"Shell vs Terminal"},{"location":"level101/linux_basics/linux_server_administration/","text":"Linux Server Administration In this course will try to cover some of the common tasks that a linux server administrator performs. We will first try to understand what a particular command does and then try to understand the commands using examples. Do keep in mind that it's very important to practice the Linux commands on your own. Lab Environment Setup Install docker on your system - https://docs.docker.com/engine/install/ We will be running all the commands on Red Hat Enterprise Linux (RHEL) 8 system. We will run most of the commands used in this module in the above Docker container. Multi-User Operating Systems An operating system is considered as multi-user if it allows multiple people/users to use a computer and not affect each other's files and preferences. Linux based operating systems are multi-user in nature as it allows multiple users to access the system at the same time. A typical computer will only have one keyboard and monitor but multiple users can log in via SSH if the computer is connected to the network. We will cover more about SSH later. As a server administrator, we are mostly concerned with the Linux servers which are physically present at a very large distance from us. We can connect to these servers with the help of remote login methods like SSH. Since Linux supports multiple users, we need to have a method which can protect the users from each other. One user should not be able to access and modify files of other users User/Group Management Users in Linux has an associated user ID called UID attached to them. Users also has a home directory and a login shell associated with them. A group is a collection of one or more users. A group makes it easier to share permissions among a group of users. Each group has a group ID called GID associated with it. id command id command can be used to find the uid and gid associated with an user. It also lists down the groups to which the user belongs to. The uid and gid associated with the root user is 0. A good way to find out the current user in Linux is to use the whoami command. \"root\" user or superuser is the most privileged user with unrestricted access to all the resources on the system. It has UID 0 Important files associated with users/groups /etc/passwd Stores the user name, the uid, the gid, the home directory, the login shell etc /etc/shadow Stores the password associated with the users /etc/group Stores information about different groups on the system If you want to understand each filed discussed in the above outputs, you can go through below links: https://tldp.org/LDP/lame/LAME/linux-admin-made-easy/shadow-file-formats.html https://tldp.org/HOWTO/User-Authentication-HOWTO/x71.html Important commands for managing users Some of the commands which are used frequently to manage users/groups on Linux are following: useradd - Creates a new user passwd - Adds or modifies passwords for a user usermod - Modifies attributes of an user userdel - Deletes an user useradd The useradd command adds a new user in Linux. We will create a new user 'shivam'. We will also verify that the user has been created by tailing the /etc/passwd file. The uid and gid are 1000 for the newly created user. The home directory assigned to the user is /home/shivam and the login shell assigned is /bin/bash. Do note that the user home directory and login shell can be modified later on. If we do not specify any value for attributes like home directory or login shell, default values will be assigned to the user. We can also override these default values when creating a new user. passwd The passwd command is used to create or modify passwords for a user. In the above examples, we have not assigned any password for users 'shivam' or 'amit' while creating them. \"!!\" in an account entry in shadow means the account of an user has been created, but not yet given a password. Let's now try to create a password for user \"shivam\". Do remember the password as we will be later using examples where it will be useful. Also, let's change the password for the root user now. When we switch from a normal user to root user, it will request you for a password. Also, when you login using root user, the password will be asked. usermod The usermod command is used to modify the attributes of an user like the home directory or the shell. Let's try to modify the login shell of user \"amit\" to \"/bin/bash\". In a similar way, you can also modify many other attributes for a user. Try 'usermod -h' for a list of attributes you can modify. userdel The userdel command is used to remove a user on Linux. Once we remove a user, all the information related to that user will be removed. Let's try to delete the user \"amit\". After deleting the user, you will not find the entry for that user in \"/etc/passwd\" or \"/etc/shadow\" file. Important commands for managing groups Commands for managing groups are quite similar to the commands used for managing users. Each command is not explained in detail here as they are quite similar. You can try running these commands on your system. groupadd \\ Creates a new group groupmod \\ Modifies attributes of a group groupdel \\ Deletes a group gpasswd \\ Modifies password for group We will now try to add user \"shivam\" to the group we have created above. Becoming a Superuser Before running the below commands, do make sure that you have set up a password for user \"shivam\" and user \"root\" using the passwd command described in the above section. The su command can be used to switch users in Linux. Let's now try to switch to user \"shivam\". Let's now try to open the \"/etc/shadow\" file. The operating system didn't allow the user \"shivam\" to read the content of the \"/etc/shadow\" file. This is an important file in Linux which stores the passwords of users. This file can only be accessed by root or users who have the superuser privileges. The sudo command allows a user to run commands with the security privileges of the root user. Do remember that the root user has all the privileges on a system. We can also use su command to switch to the root user and open the above file but doing that will require the password of the root user. An alternative way which is preferred on most modern operating systems is to use sudo command for becoming a superuser. Using this way, a user has to enter his/her password and they need to be a part of the sudo group. How to provide superpriveleges to other users ? Let's first switch to the root user using su command. Do note that using the below command will need you to enter the password for the root user. In case, you forgot to set a password for the root user, type \"exit\" and you will be back as the root user. Now, set up a password using the passwd command. The file /etc/sudoers holds the names of users permitted to invoke sudo . In redhat operating systems, this file is not present by default. We will need to install sudo. We will discuss the yum command in detail in later sections. Try to open the \"/etc/sudoers\" file on the system. The file has a lot of information. This file stores the rules that users must follow when running the sudo command. For example, root is allowed to run any commands from anywhere. One easy way of providing root access to users is to add them to a group which has permissions to run all the commands. \"wheel\" is a group in redhat Linux with such privileges. Let's add the user \"shivam\" to this group so that it also has sudo privileges. Let's now switch back to user \"shivam\" and try to access the \"/etc/shadow\" file. We need to use sudo before running the command since it can only be accessed with the sudo privileges. We have already given sudo privileges to user \u201cshivam\u201d by adding him to the group \u201cwheel\u201d. File Permissions On a Linux operating system, each file and directory is assigned access permissions for the owner of the file, the members of a group of related users and everybody else. This is to make sure that one user is not allowed to access the files and resources of another user. To see the permissions of a file, we can use the ls command. Let's look at the permissions of /etc/passwd file. Let's go over some of the important fields in the output that are related to file permissions. Chmod command The chmod command is used to modify files and directories permissions in Linux. The chmod command accepts permissions in as a numerical argument. We can think of permission as a series of bits with 1 representing True or allowed and 0 representing False or not allowed. Permission rwx Binary Decimal Read, write and execute rwx 111 7 Read and write rw- 110 6 Read and execute r-x 101 5 Read only r-- 100 4 Write and execute -wx 011 3 Write only -w- 010 2 Execute only --x 001 1 None --- 000 0 We will now create a new file and check the permission of the file. The group owner doesn't have the permission to write to this file. Let's give the group owner or root the permission to write to it using chmod command. Chmod command can be also used to change the permissions of a directory in the similar way. Chown command The chown command is used to change the owner of files or directories in Linux. Command syntax: chown \\ \\ In case, we do not have sudo privileges, we need to use sudo command . Let's switch to user 'shivam' and try changing the owner. We have also changed the owner of the file to root before running the below command. Chown command can also be used to change the owner of a directory in the similar way. Chgrp command The chgrp command can be used to change the group ownership of files or directories in Linux. The syntax is very similar to that of chown command. Chgrp command can also be used to change the owner of a directory in the similar way. SSH Command The ssh command is used for logging into the remote systems, transfer files between systems and for executing commands on a remote machine. SSH stands for secure shell and is used to provide an encrypted secured connection between two hosts over an insecure network like the internet. Reference: https://www.ssh.com/ssh/command/ We will now discuss passwordless authentication which is secure and most commonly used for ssh authentication. Passwordless Authentication Using SSH Using this method, we can ssh into hosts without entering the password. This method is also useful when we want some scripts to perform ssh-related tasks. Passwordless authentication requires the use of a public and private key pair. As the name implies, the public key can be shared with anyone but the private key should be kept private. Lets not get into the details of how this authentication works. You can read more about it here Steps for setting up a passwordless authentication with a remote host: Generating public-private key pair If we already have a key pair stored in \\~/.ssh directory, we will not need to generate keys again. Install openssh package which contains all the commands related to ssh. Generate a key pair using the ssh-keygen command. One can choose the default values for all prompts. After running the ssh-keygen command successfully, we should see two keys present in the \\~/.ssh directory. Id_rsa is the private key and id_rsa.pub is the public key. Do note that the private key can only be read and modified by you. Transferring the public key to the remote host There are multiple ways to transfer the public key to the remote server. We will look at one of the most common ways of doing it using the ssh-copy-id command. Install the openssh-clients package to use ssh-copy-id command. Use the ssh-copy-id command to copy your public key to the remote host. Now, ssh into the remote host using the password authentication. Our public key should be there in \\~/.ssh/authorized_keys now. \\~/.ssh/authorized_key contains a list of public keys. The users associated with these public keys have the ssh access into the remote host. How to run commands on a remote host ? General syntax: ssh \\@\\ \\ How to transfer files from one host to another host ? General syntax: scp \\ \\ Package Management Package management is the process of installing and managing software on the system. We can install the packages which we require from the Linux package distributor. Different distributors use different packaging systems. Packaging systems Distributions Debian style (.deb) Debian, Ubuntu Red Hat style (.rpm) Fedora, CentOS, Red Hat Enterprise Linux Popular Packaging Systems in Linux Command Description yum install \\ Installs a package on your system yum update \\ Updates a package to it's latest available version yum remove \\ Removes a package from your system yum search \\ Searches for a particular keyword DNF is the successor to YUM which is now used in Fedora for installing and managing packages. DNF may replace YUM in the future on all RPM based Linux distributions. We did find an exact match for the keyword httpd when we searched using yum search command. Let's now install the httpd package. After httpd is installed, we will use the yum remove command to remove httpd package. Process Management In this section, we will study about some useful commands that can be used to monitor the processes on Linux systems. ps (process status) The ps command is used to know the information of a process or list of processes. If you get an error \"ps command not found\" while running ps command, do install procps package. ps without any arguments is not very useful. Let's try to list all the processes on the system by using the below command. Reference: https://unix.stackexchange.com/questions/106847/what-does-aux-mean-in-ps-aux We can use an additional argument with ps command to list the information about the process with a specific process ID. We can use grep in combination with ps command to list only specific processes. top The top command is used to show information about Linux processes running on the system in real time. It also shows a summary of the system information. For each process, top lists down the process ID, owner, priority, state, cpu utilization, memory utilization and much more information. It also lists down the memory utilization and cpu utilization of the system as a whole along with system uptime and cpu load average. Memory Management In this section, we will study about some useful commands that can be used to view information about the system memory. free The free command is used to display the memory usage of the system. The command displays the total free and used space available in the RAM along with space occupied by the caches/buffers. free command by default shows the memory usage in kilobytes. We can use an additional argument to get the data in human-readable format. vmstat The vmstat command can be used to display the memory usage along with additional information about io and cpu usage. Checking Disk Space In this section, we will study about some useful commands that can be used to view disk space on Linux. df (disk free) The df command is used to display the free and available space for each mounted file system. du (disk usage) The du command is used to display disk usage of files and directories on the system. The below command can be used to display the top 5 largest directories in the root directory. Daemons A computer program that runs as a background process is called a daemon. Traditionally, the name of daemon processes ended with d - sshd, httpd etc. We cannot interact with a daemon process as they run in the background. Services and daemons are used interchangeably most of the time. Systemd Systemd is a system and service manager for Linux operating systems. Systemd units are the building blocks of systemd. These units are represented by unit configuration files. The below examples shows the unit configuration files available at /usr/lib/systemd/system which are distributed by installed RPM packages. We are more interested in the configuration file that ends with service as these are service units. Managing System Services Service units end with .service file extension. Systemctl command can be used to start/stop/restart the services managed by systemd. Command Description systemctl start name.service Starts a service systemctl stop name.service Stops a service systemctl restart name.service Restarts a service systemctl status name.service Check the status of a service systemctl reload name.service Reload the configuration of a service Logs In this section, we will talk about some important files and directories which can be very useful for viewing system logs and applications logs in Linux. These logs can be very useful when you are troubleshooting on the system.","title":"Server Administration"},{"location":"level101/linux_basics/linux_server_administration/#linux-server-administration","text":"In this course will try to cover some of the common tasks that a linux server administrator performs. We will first try to understand what a particular command does and then try to understand the commands using examples. Do keep in mind that it's very important to practice the Linux commands on your own.","title":"Linux Server Administration"},{"location":"level101/linux_basics/linux_server_administration/#lab-environment-setup","text":"Install docker on your system - https://docs.docker.com/engine/install/ We will be running all the commands on Red Hat Enterprise Linux (RHEL) 8 system. We will run most of the commands used in this module in the above Docker container.","title":"Lab Environment Setup"},{"location":"level101/linux_basics/linux_server_administration/#multi-user-operating-systems","text":"An operating system is considered as multi-user if it allows multiple people/users to use a computer and not affect each other's files and preferences. Linux based operating systems are multi-user in nature as it allows multiple users to access the system at the same time. A typical computer will only have one keyboard and monitor but multiple users can log in via SSH if the computer is connected to the network. We will cover more about SSH later. As a server administrator, we are mostly concerned with the Linux servers which are physically present at a very large distance from us. We can connect to these servers with the help of remote login methods like SSH. Since Linux supports multiple users, we need to have a method which can protect the users from each other. One user should not be able to access and modify files of other users","title":"Multi-User Operating Systems"},{"location":"level101/linux_basics/linux_server_administration/#usergroup-management","text":"Users in Linux has an associated user ID called UID attached to them. Users also has a home directory and a login shell associated with them. A group is a collection of one or more users. A group makes it easier to share permissions among a group of users. Each group has a group ID called GID associated with it.","title":"User/Group Management"},{"location":"level101/linux_basics/linux_server_administration/#id-command","text":"id command can be used to find the uid and gid associated with an user. It also lists down the groups to which the user belongs to. The uid and gid associated with the root user is 0. A good way to find out the current user in Linux is to use the whoami command. \"root\" user or superuser is the most privileged user with unrestricted access to all the resources on the system. It has UID 0","title":"id command"},{"location":"level101/linux_basics/linux_server_administration/#important-files-associated-with-usersgroups","text":"/etc/passwd Stores the user name, the uid, the gid, the home directory, the login shell etc /etc/shadow Stores the password associated with the users /etc/group Stores information about different groups on the system If you want to understand each filed discussed in the above outputs, you can go through below links: https://tldp.org/LDP/lame/LAME/linux-admin-made-easy/shadow-file-formats.html https://tldp.org/HOWTO/User-Authentication-HOWTO/x71.html","title":"Important files associated with users/groups"},{"location":"level101/linux_basics/linux_server_administration/#important-commands-for-managing-users","text":"Some of the commands which are used frequently to manage users/groups on Linux are following: useradd - Creates a new user passwd - Adds or modifies passwords for a user usermod - Modifies attributes of an user userdel - Deletes an user","title":"Important commands for managing users"},{"location":"level101/linux_basics/linux_server_administration/#useradd","text":"The useradd command adds a new user in Linux. We will create a new user 'shivam'. We will also verify that the user has been created by tailing the /etc/passwd file. The uid and gid are 1000 for the newly created user. The home directory assigned to the user is /home/shivam and the login shell assigned is /bin/bash. Do note that the user home directory and login shell can be modified later on. If we do not specify any value for attributes like home directory or login shell, default values will be assigned to the user. We can also override these default values when creating a new user.","title":"useradd"},{"location":"level101/linux_basics/linux_server_administration/#passwd","text":"The passwd command is used to create or modify passwords for a user. In the above examples, we have not assigned any password for users 'shivam' or 'amit' while creating them. \"!!\" in an account entry in shadow means the account of an user has been created, but not yet given a password. Let's now try to create a password for user \"shivam\". Do remember the password as we will be later using examples where it will be useful. Also, let's change the password for the root user now. When we switch from a normal user to root user, it will request you for a password. Also, when you login using root user, the password will be asked.","title":"passwd"},{"location":"level101/linux_basics/linux_server_administration/#usermod","text":"The usermod command is used to modify the attributes of an user like the home directory or the shell. Let's try to modify the login shell of user \"amit\" to \"/bin/bash\". In a similar way, you can also modify many other attributes for a user. Try 'usermod -h' for a list of attributes you can modify.","title":"usermod"},{"location":"level101/linux_basics/linux_server_administration/#userdel","text":"The userdel command is used to remove a user on Linux. Once we remove a user, all the information related to that user will be removed. Let's try to delete the user \"amit\". After deleting the user, you will not find the entry for that user in \"/etc/passwd\" or \"/etc/shadow\" file.","title":"userdel"},{"location":"level101/linux_basics/linux_server_administration/#important-commands-for-managing-groups","text":"Commands for managing groups are quite similar to the commands used for managing users. Each command is not explained in detail here as they are quite similar. You can try running these commands on your system. groupadd \\ Creates a new group groupmod \\ Modifies attributes of a group groupdel \\ Deletes a group gpasswd \\ Modifies password for group We will now try to add user \"shivam\" to the group we have created above.","title":"Important commands for managing groups"},{"location":"level101/linux_basics/linux_server_administration/#becoming-a-superuser","text":"Before running the below commands, do make sure that you have set up a password for user \"shivam\" and user \"root\" using the passwd command described in the above section. The su command can be used to switch users in Linux. Let's now try to switch to user \"shivam\". Let's now try to open the \"/etc/shadow\" file. The operating system didn't allow the user \"shivam\" to read the content of the \"/etc/shadow\" file. This is an important file in Linux which stores the passwords of users. This file can only be accessed by root or users who have the superuser privileges. The sudo command allows a user to run commands with the security privileges of the root user. Do remember that the root user has all the privileges on a system. We can also use su command to switch to the root user and open the above file but doing that will require the password of the root user. An alternative way which is preferred on most modern operating systems is to use sudo command for becoming a superuser. Using this way, a user has to enter his/her password and they need to be a part of the sudo group. How to provide superpriveleges to other users ? Let's first switch to the root user using su command. Do note that using the below command will need you to enter the password for the root user. In case, you forgot to set a password for the root user, type \"exit\" and you will be back as the root user. Now, set up a password using the passwd command. The file /etc/sudoers holds the names of users permitted to invoke sudo . In redhat operating systems, this file is not present by default. We will need to install sudo. We will discuss the yum command in detail in later sections. Try to open the \"/etc/sudoers\" file on the system. The file has a lot of information. This file stores the rules that users must follow when running the sudo command. For example, root is allowed to run any commands from anywhere. One easy way of providing root access to users is to add them to a group which has permissions to run all the commands. \"wheel\" is a group in redhat Linux with such privileges. Let's add the user \"shivam\" to this group so that it also has sudo privileges. Let's now switch back to user \"shivam\" and try to access the \"/etc/shadow\" file. We need to use sudo before running the command since it can only be accessed with the sudo privileges. We have already given sudo privileges to user \u201cshivam\u201d by adding him to the group \u201cwheel\u201d.","title":"Becoming a Superuser"},{"location":"level101/linux_basics/linux_server_administration/#file-permissions","text":"On a Linux operating system, each file and directory is assigned access permissions for the owner of the file, the members of a group of related users and everybody else. This is to make sure that one user is not allowed to access the files and resources of another user. To see the permissions of a file, we can use the ls command. Let's look at the permissions of /etc/passwd file. Let's go over some of the important fields in the output that are related to file permissions.","title":"File Permissions"},{"location":"level101/linux_basics/linux_server_administration/#chmod-command","text":"The chmod command is used to modify files and directories permissions in Linux. The chmod command accepts permissions in as a numerical argument. We can think of permission as a series of bits with 1 representing True or allowed and 0 representing False or not allowed. Permission rwx Binary Decimal Read, write and execute rwx 111 7 Read and write rw- 110 6 Read and execute r-x 101 5 Read only r-- 100 4 Write and execute -wx 011 3 Write only -w- 010 2 Execute only --x 001 1 None --- 000 0 We will now create a new file and check the permission of the file. The group owner doesn't have the permission to write to this file. Let's give the group owner or root the permission to write to it using chmod command. Chmod command can be also used to change the permissions of a directory in the similar way.","title":"Chmod command"},{"location":"level101/linux_basics/linux_server_administration/#chown-command","text":"The chown command is used to change the owner of files or directories in Linux. Command syntax: chown \\ \\ In case, we do not have sudo privileges, we need to use sudo command . Let's switch to user 'shivam' and try changing the owner. We have also changed the owner of the file to root before running the below command. Chown command can also be used to change the owner of a directory in the similar way.","title":"Chown command"},{"location":"level101/linux_basics/linux_server_administration/#chgrp-command","text":"The chgrp command can be used to change the group ownership of files or directories in Linux. The syntax is very similar to that of chown command. Chgrp command can also be used to change the owner of a directory in the similar way.","title":"Chgrp command"},{"location":"level101/linux_basics/linux_server_administration/#ssh-command","text":"The ssh command is used for logging into the remote systems, transfer files between systems and for executing commands on a remote machine. SSH stands for secure shell and is used to provide an encrypted secured connection between two hosts over an insecure network like the internet. Reference: https://www.ssh.com/ssh/command/ We will now discuss passwordless authentication which is secure and most commonly used for ssh authentication.","title":"SSH Command"},{"location":"level101/linux_basics/linux_server_administration/#passwordless-authentication-using-ssh","text":"Using this method, we can ssh into hosts without entering the password. This method is also useful when we want some scripts to perform ssh-related tasks. Passwordless authentication requires the use of a public and private key pair. As the name implies, the public key can be shared with anyone but the private key should be kept private. Lets not get into the details of how this authentication works. You can read more about it here Steps for setting up a passwordless authentication with a remote host: Generating public-private key pair If we already have a key pair stored in \\~/.ssh directory, we will not need to generate keys again. Install openssh package which contains all the commands related to ssh. Generate a key pair using the ssh-keygen command. One can choose the default values for all prompts. After running the ssh-keygen command successfully, we should see two keys present in the \\~/.ssh directory. Id_rsa is the private key and id_rsa.pub is the public key. Do note that the private key can only be read and modified by you. Transferring the public key to the remote host There are multiple ways to transfer the public key to the remote server. We will look at one of the most common ways of doing it using the ssh-copy-id command. Install the openssh-clients package to use ssh-copy-id command. Use the ssh-copy-id command to copy your public key to the remote host. Now, ssh into the remote host using the password authentication. Our public key should be there in \\~/.ssh/authorized_keys now. \\~/.ssh/authorized_key contains a list of public keys. The users associated with these public keys have the ssh access into the remote host.","title":"Passwordless Authentication Using SSH"},{"location":"level101/linux_basics/linux_server_administration/#how-to-run-commands-on-a-remote-host","text":"General syntax: ssh \\@\\ \\","title":"How to run commands on a remote host ?"},{"location":"level101/linux_basics/linux_server_administration/#how-to-transfer-files-from-one-host-to-another-host","text":"General syntax: scp \\ \\","title":"How to transfer files from one host to another host ?"},{"location":"level101/linux_basics/linux_server_administration/#package-management","text":"Package management is the process of installing and managing software on the system. We can install the packages which we require from the Linux package distributor. Different distributors use different packaging systems. Packaging systems Distributions Debian style (.deb) Debian, Ubuntu Red Hat style (.rpm) Fedora, CentOS, Red Hat Enterprise Linux Popular Packaging Systems in Linux Command Description yum install \\ Installs a package on your system yum update \\ Updates a package to it's latest available version yum remove \\ Removes a package from your system yum search \\ Searches for a particular keyword DNF is the successor to YUM which is now used in Fedora for installing and managing packages. DNF may replace YUM in the future on all RPM based Linux distributions. We did find an exact match for the keyword httpd when we searched using yum search command. Let's now install the httpd package. After httpd is installed, we will use the yum remove command to remove httpd package.","title":"Package Management"},{"location":"level101/linux_basics/linux_server_administration/#process-management","text":"In this section, we will study about some useful commands that can be used to monitor the processes on Linux systems.","title":"Process Management"},{"location":"level101/linux_basics/linux_server_administration/#ps-process-status","text":"The ps command is used to know the information of a process or list of processes. If you get an error \"ps command not found\" while running ps command, do install procps package. ps without any arguments is not very useful. Let's try to list all the processes on the system by using the below command. Reference: https://unix.stackexchange.com/questions/106847/what-does-aux-mean-in-ps-aux We can use an additional argument with ps command to list the information about the process with a specific process ID. We can use grep in combination with ps command to list only specific processes.","title":"ps (process status)"},{"location":"level101/linux_basics/linux_server_administration/#top","text":"The top command is used to show information about Linux processes running on the system in real time. It also shows a summary of the system information. For each process, top lists down the process ID, owner, priority, state, cpu utilization, memory utilization and much more information. It also lists down the memory utilization and cpu utilization of the system as a whole along with system uptime and cpu load average.","title":"top"},{"location":"level101/linux_basics/linux_server_administration/#memory-management","text":"In this section, we will study about some useful commands that can be used to view information about the system memory.","title":"Memory Management"},{"location":"level101/linux_basics/linux_server_administration/#free","text":"The free command is used to display the memory usage of the system. The command displays the total free and used space available in the RAM along with space occupied by the caches/buffers. free command by default shows the memory usage in kilobytes. We can use an additional argument to get the data in human-readable format.","title":"free"},{"location":"level101/linux_basics/linux_server_administration/#vmstat","text":"The vmstat command can be used to display the memory usage along with additional information about io and cpu usage.","title":"vmstat"},{"location":"level101/linux_basics/linux_server_administration/#checking-disk-space","text":"In this section, we will study about some useful commands that can be used to view disk space on Linux.","title":"Checking Disk Space"},{"location":"level101/linux_basics/linux_server_administration/#df-disk-free","text":"The df command is used to display the free and available space for each mounted file system.","title":"df (disk free)"},{"location":"level101/linux_basics/linux_server_administration/#du-disk-usage","text":"The du command is used to display disk usage of files and directories on the system. The below command can be used to display the top 5 largest directories in the root directory.","title":"du (disk usage)"},{"location":"level101/linux_basics/linux_server_administration/#daemons","text":"A computer program that runs as a background process is called a daemon. Traditionally, the name of daemon processes ended with d - sshd, httpd etc. We cannot interact with a daemon process as they run in the background. Services and daemons are used interchangeably most of the time.","title":"Daemons"},{"location":"level101/linux_basics/linux_server_administration/#systemd","text":"Systemd is a system and service manager for Linux operating systems. Systemd units are the building blocks of systemd. These units are represented by unit configuration files. The below examples shows the unit configuration files available at /usr/lib/systemd/system which are distributed by installed RPM packages. We are more interested in the configuration file that ends with service as these are service units.","title":"Systemd"},{"location":"level101/linux_basics/linux_server_administration/#managing-system-services","text":"Service units end with .service file extension. Systemctl command can be used to start/stop/restart the services managed by systemd. Command Description systemctl start name.service Starts a service systemctl stop name.service Stops a service systemctl restart name.service Restarts a service systemctl status name.service Check the status of a service systemctl reload name.service Reload the configuration of a service","title":"Managing System Services"},{"location":"level101/linux_basics/linux_server_administration/#logs","text":"In this section, we will talk about some important files and directories which can be very useful for viewing system logs and applications logs in Linux. These logs can be very useful when you are troubleshooting on the system.","title":"Logs"},{"location":"level101/linux_networking/conclusion/","text":"Conclusion With this we have traversed through the TCP/IP stack completely. We hope there will be a different perspective when one opens any website in the browser post the course. During the course we have also dissected what are common tasks in this pipeline which falls under the ambit of SRE. Post Training Exercises Setup own DNS resolver in the dev environment which acts as an authoritative DNS server for example.com and forwarder for other domains. Update resolv.conf to use the new DNS resolver running in localhost Set up a site dummy.example.com in localhost and run a webserver with a self signed certificate. Update the trusted CAs or pass self signed CA\u2019s public key as a parameter so that curl https://dummy.example.com -v works properly without self signed cert warning Update the routing table to use another host(container/VM) in the same network as a gateway for 8.8.8.8/32 and run ping 8.8.8.8. Do the packet capture on the new gateway to see L3 hop is working as expected(might need to disable icmp_redirect)","title":"Conclusion"},{"location":"level101/linux_networking/conclusion/#conclusion","text":"With this we have traversed through the TCP/IP stack completely. We hope there will be a different perspective when one opens any website in the browser post the course. During the course we have also dissected what are common tasks in this pipeline which falls under the ambit of SRE.","title":"Conclusion"},{"location":"level101/linux_networking/conclusion/#post-training-exercises","text":"Setup own DNS resolver in the dev environment which acts as an authoritative DNS server for example.com and forwarder for other domains. Update resolv.conf to use the new DNS resolver running in localhost Set up a site dummy.example.com in localhost and run a webserver with a self signed certificate. Update the trusted CAs or pass self signed CA\u2019s public key as a parameter so that curl https://dummy.example.com -v works properly without self signed cert warning Update the routing table to use another host(container/VM) in the same network as a gateway for 8.8.8.8/32 and run ping 8.8.8.8. Do the packet capture on the new gateway to see L3 hop is working as expected(might need to disable icmp_redirect)","title":"Post Training Exercises"},{"location":"level101/linux_networking/dns/","text":"DNS Domain Names are the simple human-readable names for websites. The Internet understands only IP addresses, but since memorizing incoherent numbers is not practical, domain names are used instead. These domain names are translated into IP addresses by the DNS infrastructure. When somebody tries to open www.linkedin.com in the browser, the browser tries to convert www.linkedin.com to an IP Address. This process is called DNS resolution. A simple pseudocode depicting this process looks this ip, err = getIPAddress(domainName) if err: print(\u201cunknown Host Exception while trying to resolve:%s\u201d.format(domainName)) Now let\u2019s try to understand what happens inside the getIPAddress function. The browser would have a DNS cache of its own where it checks if there is a mapping for the domainName to an IP Address already available, in which case the browser uses that IP address. If no such mapping exists, the browser calls gethostbyname syscall to ask the operating system to find the IP address for the given domainName def getIPAddress(domainName): resp, fail = lookupCache(domainName) If not fail: return resp else: resp, err = gethostbyname(domainName) if err: return null, err else: return resp Now lets understand what operating system kernel does when the gethostbyname function is called. The Linux operating system looks at the file /etc/nsswitch.conf file which usually has a line hosts: files dns This line means the OS has to look up first in file (/etc/hosts) and then use DNS protocol to do the resolution if there is no match in /etc/hosts. The file /etc/hosts is of format IPAddress FQDN [FQDN].* 127.0.0.1 localhost.localdomain localhost ::1 localhost.localdomain localhost If a match exists for a domain in this file then that IP address is returned by the OS. Lets add a line to this file 127.0.0.1 test.linkedin.com And then do ping test.linkedin.com ping test.linkedin.com -n PING test.linkedin.com (127.0.0.1) 56(84) bytes of data. 64 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.047 ms 64 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.036 ms 64 bytes from 127.0.0.1: icmp_seq=3 ttl=64 time=0.037 ms As mentioned earlier, if no match exists in /etc/hosts, the OS tries to do a DNS resolution using the DNS protocol. The linux system makes a DNS request to the first IP in /etc/resolv.conf. If there is no response, requests are sent to subsequent servers in resolv.conf. These servers in resolv.conf are called DNS resolvers. The DNS resolvers are populated by DHCP or statically configured by an administrator. Dig is a userspace DNS system which creates and sends request to DNS resolvers and prints the response it receives to the console. #run this command in one shell to capture all DNS requests sudo tcpdump -s 0 -A -i any port 53 #make a dig request from another shell dig linkedin.com 13:19:54.432507 IP 172.19.209.122.56497 > 172.23.195.101.53: 527+ [1au] A? linkedin.com. (41) ....E..E....@.n....z...e...5.1.:... .........linkedin.com.......)........ 13:19:54.485131 IP 172.23.195.101.53 > 172.19.209.122.56497: 527 1/0/1 A 108.174.10.10 (57) ....E..U..@.|. ....e...z.5...A...............linkedin.com..............3..l. ..)........ The packet capture shows a request is made to 172.23.195.101:53 (this is the resolver in /etc/resolv.conf) for linkedin.com and a response is received from 172.23.195.101 with the IP address of linkedin.com 108.174.10.10 Now let's try to understand how DNS resolver tries to find the IP address of linkedin.com. DNS resolver first looks at its cache. Since many devices in the network can query for the domain name linkedin.com, the name resolution result may already exist in the cache. If there is a cache miss, it starts the DNS resolution process. The DNS server breaks \u201clinkedin.com\u201d to \u201c.\u201d, \u201ccom.\u201d and \u201clinkedin.com.\u201d and starts DNS resolution from \u201c.\u201d. The \u201c.\u201d is called root domain and those IPs are known to the DNS resolver software. DNS resolver queries the root domain Nameservers to find the right nameservers which could respond regarding details for \"com.\". The address of the authoritative nameserver of \u201ccom.\u201d is returned. Now the DNS resolution service contacts the authoritative nameserver for \u201ccom.\u201d to fetch the authoritative nameserver for \u201clinkedin.com\u201d. Once an authoritative nameserver of \u201clinkedin.com\u201d is known, the resolver contacts Linkedin\u2019s nameserver to provide the IP address of \u201clinkedin.com\u201d. This whole process can be visualized by running dig +trace linkedin.com linkedin.com. 3600 IN A 108.174.10.10 This DNS response has 5 fields where the first field is the request and the last field is the response. The second field is the Time to Live which says how long the DNS response is valid in seconds. In this case this mapping of linkedin.com is valid for 1 hour. This is how the resolvers and application(browser) maintain their cache. Any request for linkedin.com beyond 1 hour will be treated as a cache miss as the mapping has expired its TTL and the whole process has to be redone. The 4th field says the type of DNS response/request. Some of the various DNS query types are A, AAAA, NS, TXT, PTR, MX and CNAME. - A record returns IPV4 address of the domain name - AAAA record returns the IPV6 address of the domain Name - NS record returns the authoritative nameserver for the domain name - CNAME records are aliases to the domain names. Some domains point to other domain names and resolving the latter domain name gives an IP which is used as an IP for the former domain name as well. Example www.linkedin.com\u2019s IP address is the same as 2-01-2c3e-005a.cdx.cedexis.net. - For the brevity we are not discussing other DNS record types, the RFC of each of these records are available here . dig A linkedin.com +short 108.174.10.10 dig AAAA linkedin.com +short 2620:109:c002::6cae:a0a dig NS linkedin.com +short dns3.p09.nsone.net. dns4.p09.nsone.net. dns2.p09.nsone.net. ns4.p43.dynect.net. ns1.p43.dynect.net. ns2.p43.dynect.net. ns3.p43.dynect.net. dns1.p09.nsone.net. dig www.linkedin.com CNAME +short 2-01-2c3e-005a.cdx.cedexis.net. Armed with these fundamentals of DNS lets see usecases where DNS is used by SREs. Applications in SRE role This section covers some of the common solutions SRE can derive from DNS Every company has to have its internal DNS infrastructure for intranet sites and internal services like databases and other internal applications like wiki. So there has to be a DNS infrastructure maintained for those domain names by the infrastructure team. This DNS infrastructure has to be optimized and scaled so that it doesn\u2019t become a single point of failure. Failure of the internal DNS infrastructure can cause API calls of microservices to fail and other cascading effects. DNS can also be used for discovering services. For example the hostname serviceb.internal.example.com could list instances which run service b internally in example.com company. Cloud providers provide options to enable DNS discovery( example ) DNS is used by cloud providers and CDN providers to scale their services. In Azure/AWS, Load Balancers are given a CNAME instead of IPAddress. They update the IPAddress of the Loadbalancers as they scale by changing the IP Address of alias domain names. This is one of the reasons why A records of such alias domains are short lived like 1 minute. DNS can also be used to make clients get IP addresses closer to their location so that their HTTP calls can be responded faster if the company has a presence geographically distributed. SRE also has to understand since there is no verification in DNS infrastructure, these responses can be spoofed. This is safeguarded by other protocols like HTTPS(dealt later). DNSSEC protects from forged or manipulated DNS responses. Stale DNS cache can be a problem. Some apps might still be using expired DNS records for their api calls. This is something SRE has to be wary of when doing maintenance. DNS Loadbalancing and service discovery also has to understand TTL and the servers can be removed from the pool only after waiting till TTL post the changes are made to DNS records. If this is not done, a certain portion of the traffic will fail as the server is removed before the TTL.","title":"DNS"},{"location":"level101/linux_networking/dns/#dns","text":"Domain Names are the simple human-readable names for websites. The Internet understands only IP addresses, but since memorizing incoherent numbers is not practical, domain names are used instead. These domain names are translated into IP addresses by the DNS infrastructure. When somebody tries to open www.linkedin.com in the browser, the browser tries to convert www.linkedin.com to an IP Address. This process is called DNS resolution. A simple pseudocode depicting this process looks this ip, err = getIPAddress(domainName) if err: print(\u201cunknown Host Exception while trying to resolve:%s\u201d.format(domainName)) Now let\u2019s try to understand what happens inside the getIPAddress function. The browser would have a DNS cache of its own where it checks if there is a mapping for the domainName to an IP Address already available, in which case the browser uses that IP address. If no such mapping exists, the browser calls gethostbyname syscall to ask the operating system to find the IP address for the given domainName def getIPAddress(domainName): resp, fail = lookupCache(domainName) If not fail: return resp else: resp, err = gethostbyname(domainName) if err: return null, err else: return resp Now lets understand what operating system kernel does when the gethostbyname function is called. The Linux operating system looks at the file /etc/nsswitch.conf file which usually has a line hosts: files dns This line means the OS has to look up first in file (/etc/hosts) and then use DNS protocol to do the resolution if there is no match in /etc/hosts. The file /etc/hosts is of format IPAddress FQDN [FQDN].* 127.0.0.1 localhost.localdomain localhost ::1 localhost.localdomain localhost If a match exists for a domain in this file then that IP address is returned by the OS. Lets add a line to this file 127.0.0.1 test.linkedin.com And then do ping test.linkedin.com ping test.linkedin.com -n PING test.linkedin.com (127.0.0.1) 56(84) bytes of data. 64 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.047 ms 64 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.036 ms 64 bytes from 127.0.0.1: icmp_seq=3 ttl=64 time=0.037 ms As mentioned earlier, if no match exists in /etc/hosts, the OS tries to do a DNS resolution using the DNS protocol. The linux system makes a DNS request to the first IP in /etc/resolv.conf. If there is no response, requests are sent to subsequent servers in resolv.conf. These servers in resolv.conf are called DNS resolvers. The DNS resolvers are populated by DHCP or statically configured by an administrator. Dig is a userspace DNS system which creates and sends request to DNS resolvers and prints the response it receives to the console. #run this command in one shell to capture all DNS requests sudo tcpdump -s 0 -A -i any port 53 #make a dig request from another shell dig linkedin.com 13:19:54.432507 IP 172.19.209.122.56497 > 172.23.195.101.53: 527+ [1au] A? linkedin.com. (41) ....E..E....@.n....z...e...5.1.:... .........linkedin.com.......)........ 13:19:54.485131 IP 172.23.195.101.53 > 172.19.209.122.56497: 527 1/0/1 A 108.174.10.10 (57) ....E..U..@.|. ....e...z.5...A...............linkedin.com..............3..l. ..)........ The packet capture shows a request is made to 172.23.195.101:53 (this is the resolver in /etc/resolv.conf) for linkedin.com and a response is received from 172.23.195.101 with the IP address of linkedin.com 108.174.10.10 Now let's try to understand how DNS resolver tries to find the IP address of linkedin.com. DNS resolver first looks at its cache. Since many devices in the network can query for the domain name linkedin.com, the name resolution result may already exist in the cache. If there is a cache miss, it starts the DNS resolution process. The DNS server breaks \u201clinkedin.com\u201d to \u201c.\u201d, \u201ccom.\u201d and \u201clinkedin.com.\u201d and starts DNS resolution from \u201c.\u201d. The \u201c.\u201d is called root domain and those IPs are known to the DNS resolver software. DNS resolver queries the root domain Nameservers to find the right nameservers which could respond regarding details for \"com.\". The address of the authoritative nameserver of \u201ccom.\u201d is returned. Now the DNS resolution service contacts the authoritative nameserver for \u201ccom.\u201d to fetch the authoritative nameserver for \u201clinkedin.com\u201d. Once an authoritative nameserver of \u201clinkedin.com\u201d is known, the resolver contacts Linkedin\u2019s nameserver to provide the IP address of \u201clinkedin.com\u201d. This whole process can be visualized by running dig +trace linkedin.com linkedin.com. 3600 IN A 108.174.10.10 This DNS response has 5 fields where the first field is the request and the last field is the response. The second field is the Time to Live which says how long the DNS response is valid in seconds. In this case this mapping of linkedin.com is valid for 1 hour. This is how the resolvers and application(browser) maintain their cache. Any request for linkedin.com beyond 1 hour will be treated as a cache miss as the mapping has expired its TTL and the whole process has to be redone. The 4th field says the type of DNS response/request. Some of the various DNS query types are A, AAAA, NS, TXT, PTR, MX and CNAME. - A record returns IPV4 address of the domain name - AAAA record returns the IPV6 address of the domain Name - NS record returns the authoritative nameserver for the domain name - CNAME records are aliases to the domain names. Some domains point to other domain names and resolving the latter domain name gives an IP which is used as an IP for the former domain name as well. Example www.linkedin.com\u2019s IP address is the same as 2-01-2c3e-005a.cdx.cedexis.net. - For the brevity we are not discussing other DNS record types, the RFC of each of these records are available here . dig A linkedin.com +short 108.174.10.10 dig AAAA linkedin.com +short 2620:109:c002::6cae:a0a dig NS linkedin.com +short dns3.p09.nsone.net. dns4.p09.nsone.net. dns2.p09.nsone.net. ns4.p43.dynect.net. ns1.p43.dynect.net. ns2.p43.dynect.net. ns3.p43.dynect.net. dns1.p09.nsone.net. dig www.linkedin.com CNAME +short 2-01-2c3e-005a.cdx.cedexis.net. Armed with these fundamentals of DNS lets see usecases where DNS is used by SREs.","title":"DNS"},{"location":"level101/linux_networking/dns/#applications-in-sre-role","text":"This section covers some of the common solutions SRE can derive from DNS Every company has to have its internal DNS infrastructure for intranet sites and internal services like databases and other internal applications like wiki. So there has to be a DNS infrastructure maintained for those domain names by the infrastructure team. This DNS infrastructure has to be optimized and scaled so that it doesn\u2019t become a single point of failure. Failure of the internal DNS infrastructure can cause API calls of microservices to fail and other cascading effects. DNS can also be used for discovering services. For example the hostname serviceb.internal.example.com could list instances which run service b internally in example.com company. Cloud providers provide options to enable DNS discovery( example ) DNS is used by cloud providers and CDN providers to scale their services. In Azure/AWS, Load Balancers are given a CNAME instead of IPAddress. They update the IPAddress of the Loadbalancers as they scale by changing the IP Address of alias domain names. This is one of the reasons why A records of such alias domains are short lived like 1 minute. DNS can also be used to make clients get IP addresses closer to their location so that their HTTP calls can be responded faster if the company has a presence geographically distributed. SRE also has to understand since there is no verification in DNS infrastructure, these responses can be spoofed. This is safeguarded by other protocols like HTTPS(dealt later). DNSSEC protects from forged or manipulated DNS responses. Stale DNS cache can be a problem. Some apps might still be using expired DNS records for their api calls. This is something SRE has to be wary of when doing maintenance. DNS Loadbalancing and service discovery also has to understand TTL and the servers can be removed from the pool only after waiting till TTL post the changes are made to DNS records. If this is not done, a certain portion of the traffic will fail as the server is removed before the TTL.","title":"Applications in SRE role"},{"location":"level101/linux_networking/http/","text":"HTTP Till this point we have only got the IP address of linkedin.com. The HTML page of linkedin.com is served by HTTP protocol which the browser renders. Browser sends a HTTP request to the IP of the server determined above. Request has a verb GET, PUT, POST followed by a path and query parameters and lines of key value pair which gives information about the client and capabilities of the client like contents it can accept and a body (usually in POST or PUT) # Eg run the following in your container and have a look at the headers curl linkedin.com -v * Connected to linkedin.com (108.174.10.10) port 80 (#0) > GET / HTTP/1.1 > Host: linkedin.com > User-Agent: curl/7.64.1 > Accept: */* > < HTTP/1.1 301 Moved Permanently < Date: Mon, 09 Nov 2020 10:39:43 GMT < X-Li-Pop: prod-esv5 < X-LI-Proto: http/1.1 < Location: https://www.linkedin.com/ < Content-Length: 0 < * Connection #0 to host linkedin.com left intact * Closing connection 0 Here, in the first line GET is the verb, / is the path and 1.1 is the HTTP protocol version. Then there are key value pairs which give client capabilities and some details to the server. The server responds back with HTTP version, Status Code and Status message . Status codes 2xx means success, 3xx denotes redirection, 4xx denotes client side errors and 5xx server side errors. We will now jump in to see the difference between HTTP/1.0 and HTTP/1.1. #On the terminal type telnet www.linkedin.com 80 #Copy and paste the following with an empty new line at last in the telnet STDIN GET / HTTP/1.1 HOST:linkedin.com USER-AGENT: curl This would get server response and waits for next input as the underlying connection to www.linkedin.com can be reused for further queries. While going through TCP, we can understand the benefits of this. But in HTTP/1.0 this connection will be immediately closed after the response meaning new connection has to be opened for each query. HTTP/1.1 can have only one inflight request in an open connection but connection can be reused for multiple requests one after another. One of the benefits of HTTP/2.0 over HTTP/1.1 is we can have multiple inflight requests on the same connection. We are restricting our scope to generic HTTP and not jumping to the intricacies of each protocol version but they should be straight forward to understand post the course. HTTP is called stateless protocol . This section we will try to understand what stateless means. Say we logged in to linkedin.com, each request to linkedin.com from the client will have no context of the user and it makes no sense to prompt user to login for each page/resource. This problem of HTTP is solved by COOKIE . A user is created a session when a user logs in. This session identifier is sent to the browser via SET-COOKIE header. The browser stores the COOKIE till the expiry set by the server and sends the cookie for each request from hereon for linkedin.com. More details on cookies are available here . Cookies are a critical piece of information like password and since HTTP is a plain text protocol, any man in the middle can capture either password or cookies and can breach the privacy of the user. Similarly as discussed during DNS a spoofed IP of linkedin.com can cause a phishing attack on users where an user can give linkedin\u2019s password to login on the malicious site. To solve both problems HTTPs came in place and HTTPs has to be mandated. HTTPS has to provide server identification and encryption of data between client and server. The server administrator has to generate a private public key pair and certificate request. This certificate request has to be signed by a certificate authority which converts the certificate request to a certificate. The server administrator has to update the certificate and private key to the webserver. The certificate has details about the server (like domain name for which it serves, expiry date), public key of the server. The private key is a secret to the server and losing the private key loses the trust the server provides. When clients connect, the client sends a HELLO. The server sends its certificate to the client. The client checks the validity of the cert by seeing if it is within its expiry time, if it is signed by a trusted authority and the hostname in the cert is the same as the server. This validation makes sure the server is the right server and there is no phishing. Once that is validated, the client negotiates a symmetrical key and cipher with the server by encrypting the negotiation with the public key of the server. Nobody else other than the server who has the private key can understand this data. Once negotiation is complete, that symmetric key and algorithm is used for further encryption which can be decrypted only by client and server from thereon as they only know the symmetric key and algorithm. The switch to symmetric algorithm from asymmetric encryption algorithm is to not strain the resources of client devices as symmetric encryption is generally less resource intensive than asymmetric. #Try the following on your terminal to see the cert details like Subject Name(domain name), Issuer details, Expiry date curl https://www.linkedin.com -v * Connected to www.linkedin.com (13.107.42.14) port 443 (#0) * ALPN, offering h2 * ALPN, offering http/1.1 * successfully set certificate verify locations: * CAfile: /etc/ssl/cert.pem CApath: none * TLSv1.2 (OUT), TLS handshake, Client hello (1): } [230 bytes data] * TLSv1.2 (IN), TLS handshake, Server hello (2): { [90 bytes data] * TLSv1.2 (IN), TLS handshake, Certificate (11): { [3171 bytes data] * TLSv1.2 (IN), TLS handshake, Server key exchange (12): { [365 bytes data] * TLSv1.2 (IN), TLS handshake, Server finished (14): { [4 bytes data] * TLSv1.2 (OUT), TLS handshake, Client key exchange (16): } [102 bytes data] * TLSv1.2 (OUT), TLS change cipher, Change cipher spec (1): } [1 bytes data] * TLSv1.2 (OUT), TLS handshake, Finished (20): } [16 bytes data] * TLSv1.2 (IN), TLS change cipher, Change cipher spec (1): { [1 bytes data] * TLSv1.2 (IN), TLS handshake, Finished (20): { [16 bytes data] * SSL connection using TLSv1.2 / ECDHE-RSA-AES256-GCM-SHA384 * ALPN, server accepted to use h2 * Server certificate: * subject: C=US; ST=California; L=Sunnyvale; O=LinkedIn Corporation; CN=www.linkedin.com * start date: Oct 2 00:00:00 2020 GMT * expire date: Apr 2 12:00:00 2021 GMT * subjectAltName: host \"www.linkedin.com\" matched cert's \"www.linkedin.com\" * issuer: C=US; O=DigiCert Inc; CN=DigiCert SHA2 Secure Server CA * SSL certificate verify ok. * Using HTTP2, server supports multi-use * Connection state changed (HTTP/2 confirmed) * Copying HTTP/2 data in stream buffer to connection buffer after upgrade: len=0 * Using Stream ID: 1 (easy handle 0x7fb055808200) * Connection state changed (MAX_CONCURRENT_STREAMS == 100)! 0 82117 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0 * Connection #0 to host www.linkedin.com left intact HTTP/2 200 cache-control: no-cache, no-store pragma: no-cache content-length: 82117 content-type: text/html; charset=utf-8 expires: Thu, 01 Jan 1970 00:00:00 GMT set-cookie: JSESSIONID=ajax:2747059799136291014; SameSite=None; Path=/; Domain=.www.linkedin.com; Secure set-cookie: lang=v=2&lang=en-us; SameSite=None; Path=/; Domain=linkedin.com; Secure set-cookie: bcookie=\"v=2&70bd59e3-5a51-406c-8e0d-dd70befa8890\"; domain=.linkedin.com; Path=/; Secure; Expires=Wed, 09-Nov-2022 22:27:42 GMT; SameSite=None set-cookie: bscookie=\"v=1&202011091050107ae9b7ac-fe97-40fc-830d-d7a9ccf80659AQGib5iXwarbY8CCBP94Q39THkgUlx6J\"; domain=.www.linkedin.com; Path=/; Secure; Expires=Wed, 09-Nov-2022 22:27:42 GMT; HttpOnly; SameSite=None set-cookie: lissc=1; domain=.linkedin.com; Path=/; Secure; Expires=Tue, 09-Nov-2021 10:50:10 GMT; SameSite=None set-cookie: lidc=\"b=VGST04:s=V:r=V:g=2201:u=1:i=1604919010:t=1605005410:v=1:sig=AQHe-KzU8i_5Iy6MwnFEsgRct3c9Lh5R\"; Expires=Tue, 10 Nov 2020 10:50:10 GMT; domain=.linkedin.com; Path=/; SameSite=None; Secure x-fs-txn-id: 2b8d5409ba70 x-fs-uuid: 61bbf94956d14516302567fc882b0000 expect-ct: max-age=86400, report-uri=\"https://www.linkedin.com/platform-telemetry/ct\" x-xss-protection: 1; mode=block content-security-policy-report-only: default-src 'none'; connect-src 'self' www.linkedin.com www.google-analytics.com https://dpm.demdex.net/id lnkd.demdex.net blob: https://linkedin.sc.omtrdc.net/b/ss/ static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; script-src 'sha256-THuVhwbXPeTR0HszASqMOnIyxqEgvGyBwSPBKBF/iMc=' 'sha256-PyCXNcEkzRWqbiNr087fizmiBBrq9O6GGD8eV3P09Ik=' 'sha256-2SQ55Erm3CPCb+k03EpNxU9bdV3XL9TnVTriDs7INZ4=' 'sha256-S/KSPe186K/1B0JEjbIXcCdpB97krdzX05S+dHnQjUs=' platform.linkedin.com platform-akam.linkedin.com platform-ecst.linkedin.com platform-azur.linkedin.com static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; img-src data: blob: *; font-src data: *; style-src 'self' 'unsafe-inline' static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; media-src dms.licdn.com; child-src blob: *; frame-src 'self' lnkd.demdex.net linkedin.cdn.qualaroo.com; manifest-src 'self'; report-uri https://www.linkedin.com/platform-telemetry/csp?f=g content-security-policy: default-src *; connect-src 'self' https://media-src.linkedin.com/media/ www.linkedin.com s.c.lnkd.licdn.com m.c.lnkd.licdn.com s.c.exp1.licdn.com s.c.exp2.licdn.com m.c.exp1.licdn.com m.c.exp2.licdn.com wss://*.linkedin.com dms.licdn.com https://dpm.demdex.net/id lnkd.demdex.net blob: https://accounts.google.com/gsi/status https://linkedin.sc.omtrdc.net/b/ss/ www.google-analytics.com static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com media.licdn.com media-exp1.licdn.com media-exp2.licdn.com media-exp3.licdn.com; img-src data: blob: *; font-src data: *; style-src 'unsafe-inline' 'self' static-src.linkedin.com *.licdn.com; script-src 'report-sample' 'unsafe-inline' 'unsafe-eval' 'self' spdy.linkedin.com static-src.linkedin.com *.ads.linkedin.com *.licdn.com static.chartbeat.com www.google-analytics.com ssl.google-analytics.com bcvipva02.rightnowtech.com www.bizographics.com sjs.bizographics.com js.bizographics.com d.la4-c1-was.salesforceliveagent.com slideshare.www.linkedin.com https://snap.licdn.com/li.lms-analytics/ platform.linkedin.com platform-akam.linkedin.com platform-ecst.linkedin.com platform-azur.linkedin.com; object-src 'none'; media-src blob: *; child-src blob: lnkd-communities: voyager: *; frame-ancestors 'self'; report-uri https://www.linkedin.com/platform-telemetry/csp?f=l x-frame-options: sameorigin x-content-type-options: nosniff strict-transport-security: max-age=2592000 x-li-fabric: prod-lva1 x-li-pop: afd-prod-lva1 x-li-proto: http/2 x-li-uuid: Ybv5SVbRRRYwJWf8iCsAAA== x-msedge-ref: Ref A: CFB9AC1D2B0645DDB161CEE4A4909AEF Ref B: BOM02EDGE0712 Ref C: 2020-11-09T10:50:10Z date: Mon, 09 Nov 2020 10:50:10 GMT * Closing connection 0 Here my system has a list of certificate authorities it trusts in this file /etc/ssl/cert.pem. Curl validates the certificate is for www.linkedin.com by seeing the CN section of the subject part of the certificate. It also makes sure the certificate is not expired by seeing the expire date. It also validates the signature on the certificate by using the public key of issuer Digicert in /etc/ssl/cert.pem. Once this is done, using the public key of www.linkedin.com it negotiates cipher TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 with a symmetric key. Subsequent data transfer including first HTTP request uses the same cipher and symmetric key.","title":"HTTP"},{"location":"level101/linux_networking/http/#http","text":"Till this point we have only got the IP address of linkedin.com. The HTML page of linkedin.com is served by HTTP protocol which the browser renders. Browser sends a HTTP request to the IP of the server determined above. Request has a verb GET, PUT, POST followed by a path and query parameters and lines of key value pair which gives information about the client and capabilities of the client like contents it can accept and a body (usually in POST or PUT) # Eg run the following in your container and have a look at the headers curl linkedin.com -v * Connected to linkedin.com (108.174.10.10) port 80 (#0) > GET / HTTP/1.1 > Host: linkedin.com > User-Agent: curl/7.64.1 > Accept: */* > < HTTP/1.1 301 Moved Permanently < Date: Mon, 09 Nov 2020 10:39:43 GMT < X-Li-Pop: prod-esv5 < X-LI-Proto: http/1.1 < Location: https://www.linkedin.com/ < Content-Length: 0 < * Connection #0 to host linkedin.com left intact * Closing connection 0 Here, in the first line GET is the verb, / is the path and 1.1 is the HTTP protocol version. Then there are key value pairs which give client capabilities and some details to the server. The server responds back with HTTP version, Status Code and Status message . Status codes 2xx means success, 3xx denotes redirection, 4xx denotes client side errors and 5xx server side errors. We will now jump in to see the difference between HTTP/1.0 and HTTP/1.1. #On the terminal type telnet www.linkedin.com 80 #Copy and paste the following with an empty new line at last in the telnet STDIN GET / HTTP/1.1 HOST:linkedin.com USER-AGENT: curl This would get server response and waits for next input as the underlying connection to www.linkedin.com can be reused for further queries. While going through TCP, we can understand the benefits of this. But in HTTP/1.0 this connection will be immediately closed after the response meaning new connection has to be opened for each query. HTTP/1.1 can have only one inflight request in an open connection but connection can be reused for multiple requests one after another. One of the benefits of HTTP/2.0 over HTTP/1.1 is we can have multiple inflight requests on the same connection. We are restricting our scope to generic HTTP and not jumping to the intricacies of each protocol version but they should be straight forward to understand post the course. HTTP is called stateless protocol . This section we will try to understand what stateless means. Say we logged in to linkedin.com, each request to linkedin.com from the client will have no context of the user and it makes no sense to prompt user to login for each page/resource. This problem of HTTP is solved by COOKIE . A user is created a session when a user logs in. This session identifier is sent to the browser via SET-COOKIE header. The browser stores the COOKIE till the expiry set by the server and sends the cookie for each request from hereon for linkedin.com. More details on cookies are available here . Cookies are a critical piece of information like password and since HTTP is a plain text protocol, any man in the middle can capture either password or cookies and can breach the privacy of the user. Similarly as discussed during DNS a spoofed IP of linkedin.com can cause a phishing attack on users where an user can give linkedin\u2019s password to login on the malicious site. To solve both problems HTTPs came in place and HTTPs has to be mandated. HTTPS has to provide server identification and encryption of data between client and server. The server administrator has to generate a private public key pair and certificate request. This certificate request has to be signed by a certificate authority which converts the certificate request to a certificate. The server administrator has to update the certificate and private key to the webserver. The certificate has details about the server (like domain name for which it serves, expiry date), public key of the server. The private key is a secret to the server and losing the private key loses the trust the server provides. When clients connect, the client sends a HELLO. The server sends its certificate to the client. The client checks the validity of the cert by seeing if it is within its expiry time, if it is signed by a trusted authority and the hostname in the cert is the same as the server. This validation makes sure the server is the right server and there is no phishing. Once that is validated, the client negotiates a symmetrical key and cipher with the server by encrypting the negotiation with the public key of the server. Nobody else other than the server who has the private key can understand this data. Once negotiation is complete, that symmetric key and algorithm is used for further encryption which can be decrypted only by client and server from thereon as they only know the symmetric key and algorithm. The switch to symmetric algorithm from asymmetric encryption algorithm is to not strain the resources of client devices as symmetric encryption is generally less resource intensive than asymmetric. #Try the following on your terminal to see the cert details like Subject Name(domain name), Issuer details, Expiry date curl https://www.linkedin.com -v * Connected to www.linkedin.com (13.107.42.14) port 443 (#0) * ALPN, offering h2 * ALPN, offering http/1.1 * successfully set certificate verify locations: * CAfile: /etc/ssl/cert.pem CApath: none * TLSv1.2 (OUT), TLS handshake, Client hello (1): } [230 bytes data] * TLSv1.2 (IN), TLS handshake, Server hello (2): { [90 bytes data] * TLSv1.2 (IN), TLS handshake, Certificate (11): { [3171 bytes data] * TLSv1.2 (IN), TLS handshake, Server key exchange (12): { [365 bytes data] * TLSv1.2 (IN), TLS handshake, Server finished (14): { [4 bytes data] * TLSv1.2 (OUT), TLS handshake, Client key exchange (16): } [102 bytes data] * TLSv1.2 (OUT), TLS change cipher, Change cipher spec (1): } [1 bytes data] * TLSv1.2 (OUT), TLS handshake, Finished (20): } [16 bytes data] * TLSv1.2 (IN), TLS change cipher, Change cipher spec (1): { [1 bytes data] * TLSv1.2 (IN), TLS handshake, Finished (20): { [16 bytes data] * SSL connection using TLSv1.2 / ECDHE-RSA-AES256-GCM-SHA384 * ALPN, server accepted to use h2 * Server certificate: * subject: C=US; ST=California; L=Sunnyvale; O=LinkedIn Corporation; CN=www.linkedin.com * start date: Oct 2 00:00:00 2020 GMT * expire date: Apr 2 12:00:00 2021 GMT * subjectAltName: host \"www.linkedin.com\" matched cert's \"www.linkedin.com\" * issuer: C=US; O=DigiCert Inc; CN=DigiCert SHA2 Secure Server CA * SSL certificate verify ok. * Using HTTP2, server supports multi-use * Connection state changed (HTTP/2 confirmed) * Copying HTTP/2 data in stream buffer to connection buffer after upgrade: len=0 * Using Stream ID: 1 (easy handle 0x7fb055808200) * Connection state changed (MAX_CONCURRENT_STREAMS == 100)! 0 82117 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0 * Connection #0 to host www.linkedin.com left intact HTTP/2 200 cache-control: no-cache, no-store pragma: no-cache content-length: 82117 content-type: text/html; charset=utf-8 expires: Thu, 01 Jan 1970 00:00:00 GMT set-cookie: JSESSIONID=ajax:2747059799136291014; SameSite=None; Path=/; Domain=.www.linkedin.com; Secure set-cookie: lang=v=2&lang=en-us; SameSite=None; Path=/; Domain=linkedin.com; Secure set-cookie: bcookie=\"v=2&70bd59e3-5a51-406c-8e0d-dd70befa8890\"; domain=.linkedin.com; Path=/; Secure; Expires=Wed, 09-Nov-2022 22:27:42 GMT; SameSite=None set-cookie: bscookie=\"v=1&202011091050107ae9b7ac-fe97-40fc-830d-d7a9ccf80659AQGib5iXwarbY8CCBP94Q39THkgUlx6J\"; domain=.www.linkedin.com; Path=/; Secure; Expires=Wed, 09-Nov-2022 22:27:42 GMT; HttpOnly; SameSite=None set-cookie: lissc=1; domain=.linkedin.com; Path=/; Secure; Expires=Tue, 09-Nov-2021 10:50:10 GMT; SameSite=None set-cookie: lidc=\"b=VGST04:s=V:r=V:g=2201:u=1:i=1604919010:t=1605005410:v=1:sig=AQHe-KzU8i_5Iy6MwnFEsgRct3c9Lh5R\"; Expires=Tue, 10 Nov 2020 10:50:10 GMT; domain=.linkedin.com; Path=/; SameSite=None; Secure x-fs-txn-id: 2b8d5409ba70 x-fs-uuid: 61bbf94956d14516302567fc882b0000 expect-ct: max-age=86400, report-uri=\"https://www.linkedin.com/platform-telemetry/ct\" x-xss-protection: 1; mode=block content-security-policy-report-only: default-src 'none'; connect-src 'self' www.linkedin.com www.google-analytics.com https://dpm.demdex.net/id lnkd.demdex.net blob: https://linkedin.sc.omtrdc.net/b/ss/ static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; script-src 'sha256-THuVhwbXPeTR0HszASqMOnIyxqEgvGyBwSPBKBF/iMc=' 'sha256-PyCXNcEkzRWqbiNr087fizmiBBrq9O6GGD8eV3P09Ik=' 'sha256-2SQ55Erm3CPCb+k03EpNxU9bdV3XL9TnVTriDs7INZ4=' 'sha256-S/KSPe186K/1B0JEjbIXcCdpB97krdzX05S+dHnQjUs=' platform.linkedin.com platform-akam.linkedin.com platform-ecst.linkedin.com platform-azur.linkedin.com static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; img-src data: blob: *; font-src data: *; style-src 'self' 'unsafe-inline' static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; media-src dms.licdn.com; child-src blob: *; frame-src 'self' lnkd.demdex.net linkedin.cdn.qualaroo.com; manifest-src 'self'; report-uri https://www.linkedin.com/platform-telemetry/csp?f=g content-security-policy: default-src *; connect-src 'self' https://media-src.linkedin.com/media/ www.linkedin.com s.c.lnkd.licdn.com m.c.lnkd.licdn.com s.c.exp1.licdn.com s.c.exp2.licdn.com m.c.exp1.licdn.com m.c.exp2.licdn.com wss://*.linkedin.com dms.licdn.com https://dpm.demdex.net/id lnkd.demdex.net blob: https://accounts.google.com/gsi/status https://linkedin.sc.omtrdc.net/b/ss/ www.google-analytics.com static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com media.licdn.com media-exp1.licdn.com media-exp2.licdn.com media-exp3.licdn.com; img-src data: blob: *; font-src data: *; style-src 'unsafe-inline' 'self' static-src.linkedin.com *.licdn.com; script-src 'report-sample' 'unsafe-inline' 'unsafe-eval' 'self' spdy.linkedin.com static-src.linkedin.com *.ads.linkedin.com *.licdn.com static.chartbeat.com www.google-analytics.com ssl.google-analytics.com bcvipva02.rightnowtech.com www.bizographics.com sjs.bizographics.com js.bizographics.com d.la4-c1-was.salesforceliveagent.com slideshare.www.linkedin.com https://snap.licdn.com/li.lms-analytics/ platform.linkedin.com platform-akam.linkedin.com platform-ecst.linkedin.com platform-azur.linkedin.com; object-src 'none'; media-src blob: *; child-src blob: lnkd-communities: voyager: *; frame-ancestors 'self'; report-uri https://www.linkedin.com/platform-telemetry/csp?f=l x-frame-options: sameorigin x-content-type-options: nosniff strict-transport-security: max-age=2592000 x-li-fabric: prod-lva1 x-li-pop: afd-prod-lva1 x-li-proto: http/2 x-li-uuid: Ybv5SVbRRRYwJWf8iCsAAA== x-msedge-ref: Ref A: CFB9AC1D2B0645DDB161CEE4A4909AEF Ref B: BOM02EDGE0712 Ref C: 2020-11-09T10:50:10Z date: Mon, 09 Nov 2020 10:50:10 GMT * Closing connection 0 Here my system has a list of certificate authorities it trusts in this file /etc/ssl/cert.pem. Curl validates the certificate is for www.linkedin.com by seeing the CN section of the subject part of the certificate. It also makes sure the certificate is not expired by seeing the expire date. It also validates the signature on the certificate by using the public key of issuer Digicert in /etc/ssl/cert.pem. Once this is done, using the public key of www.linkedin.com it negotiates cipher TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 with a symmetric key. Subsequent data transfer including first HTTP request uses the same cipher and symmetric key.","title":"HTTP"},{"location":"level101/linux_networking/intro/","text":"Linux Networking Fundamentals Prerequisites High-level knowledge of commonly used jargon in TCP/IP stack like DNS, TCP, UDP and HTTP Linux Commandline Basics What to expect from this course Throughout the course, we cover how an SRE can optimize the system to improve their web stack performance and troubleshoot if there is an issue in any of the layers of the networking stack. This course tries to dig through each layer of traditional TCP/IP stack and expects an SRE to have a picture beyond the bird\u2019s eye view of the functioning of the Internet. What is not covered under this course This course spends time on the fundamentals. We are not covering concepts like HTTP/2.0 , QUIC , TCP congestion control protocols , Anycast , BGP , CDN , Tunnels and Multicast . We expect that this course will provide the relevant basics to understand such concepts Birds eye view of the course The course covers the question \u201cWhat happens when you open linkedin.com in your browser?\u201d The course follows the flow of TCP/IP stack.More specifically, the course covers topics of Application layer protocols DNS and HTTP, transport layer protocols UDP and TCP, networking layer protocol IP and Data Link Layer protocol Course Contents DNS UDP HTTP TCP IP Routing","title":"Introduction"},{"location":"level101/linux_networking/intro/#linux-networking-fundamentals","text":"","title":"Linux Networking Fundamentals"},{"location":"level101/linux_networking/intro/#prerequisites","text":"High-level knowledge of commonly used jargon in TCP/IP stack like DNS, TCP, UDP and HTTP Linux Commandline Basics","title":"Prerequisites"},{"location":"level101/linux_networking/intro/#what-to-expect-from-this-course","text":"Throughout the course, we cover how an SRE can optimize the system to improve their web stack performance and troubleshoot if there is an issue in any of the layers of the networking stack. This course tries to dig through each layer of traditional TCP/IP stack and expects an SRE to have a picture beyond the bird\u2019s eye view of the functioning of the Internet.","title":"What to expect from this course"},{"location":"level101/linux_networking/intro/#what-is-not-covered-under-this-course","text":"This course spends time on the fundamentals. We are not covering concepts like HTTP/2.0 , QUIC , TCP congestion control protocols , Anycast , BGP , CDN , Tunnels and Multicast . We expect that this course will provide the relevant basics to understand such concepts","title":"What is not covered under this course"},{"location":"level101/linux_networking/intro/#birds-eye-view-of-the-course","text":"The course covers the question \u201cWhat happens when you open linkedin.com in your browser?\u201d The course follows the flow of TCP/IP stack.More specifically, the course covers topics of Application layer protocols DNS and HTTP, transport layer protocols UDP and TCP, networking layer protocol IP and Data Link Layer protocol","title":"Birds eye view of the course"},{"location":"level101/linux_networking/intro/#course-contents","text":"DNS UDP HTTP TCP IP Routing","title":"Course Contents"},{"location":"level101/linux_networking/ipr/","text":"IP Routing and Data Link Layer We will dig how packets that leave the client reach the server and vice versa. When the packet reaches the IP layer, the transport layer populates source port, destination port. IP/Network layer populates destination IP(discovered from DNS) and then looks up the route to the destination IP on the routing table. #Linux route -n command gives the default routing table route -n Kernel IP routing table Destination Gateway Genmask Flags Metric Ref Use Iface 0.0.0.0 172.17.0.1 0.0.0.0 UG 0 0 0 eth0 172.17.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth0 Here the destination IP is bitwise AND\u2019d with the Genmask and if the answer is the destination part of the table then that gateway and interface is picked for routing. Here linkedin.com\u2019s IP 108.174.10.10 is AND\u2019d with 255.255.255.0 and the answer we get is 108.174.10.0 which doesn\u2019t match with any destination in the routing table. Then Linux does an AND of destination IP with 0.0.0.0 and we get 0.0.0.0. This answer matches the default row Routing table is processed in the order of more octets of 1 set in genmask and genmask 0.0.0.0 is the default route if nothing matches. At the end of this operation Linux figured out that the packet has to be sent to next hop 172.17.0.1 via eth0. The source IP of the packet will be set as the IP of interface eth0. Now to send the packet to 172.17.0.1 linux has to figure out the MAC address of 172.17.0.1. MAC address is figured by looking at the internal arp cache which stores translation between IP address and MAC address. If there is a cache miss, Linux broadcasts ARP request within the internal network asking who has 172.17.0.1. The owner of the IP sends an ARP response which is cached by the kernel and the kernel sends the packet to the gateway by setting Source mac address as mac address of eth0 and destination mac address of 172.17.0.1 which we got just now. Similar routing lookup process is followed in each hop till the packet reaches the actual server. Transport layer and layers above it come to play only at end servers. During intermediate hops only till the IP/Network layer is involved. One weird gateway we saw in the routing table is 0.0.0.0. This gateway means no Layer3(Network layer) hop is needed to send the packet. Both source and destination are in the same network. Kernel has to figure out the mac of the destination and populate source and destination mac appropriately and send the packet out so that it reaches the destination without any Layer3 hop in the middle As we followed in other modules, lets complete this session with SRE usecases Applications in SRE role Generally the routing table is populated by DHCP and playing around is not a good practice. There can be reasons where one has to play around the routing table but take that path only when it's absolutely necessary Understanding error messages better like, \u201cNo route to host\u201d error can mean mac address of the destination host is not found and it can mean the destination host is down On rare cases looking at the ARP table can help us understand if there is a IP conflict where same IP is assigned to two hosts by mistake and this is causing unexpected behavior","title":"Routing"},{"location":"level101/linux_networking/ipr/#ip-routing-and-data-link-layer","text":"We will dig how packets that leave the client reach the server and vice versa. When the packet reaches the IP layer, the transport layer populates source port, destination port. IP/Network layer populates destination IP(discovered from DNS) and then looks up the route to the destination IP on the routing table. #Linux route -n command gives the default routing table route -n Kernel IP routing table Destination Gateway Genmask Flags Metric Ref Use Iface 0.0.0.0 172.17.0.1 0.0.0.0 UG 0 0 0 eth0 172.17.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth0 Here the destination IP is bitwise AND\u2019d with the Genmask and if the answer is the destination part of the table then that gateway and interface is picked for routing. Here linkedin.com\u2019s IP 108.174.10.10 is AND\u2019d with 255.255.255.0 and the answer we get is 108.174.10.0 which doesn\u2019t match with any destination in the routing table. Then Linux does an AND of destination IP with 0.0.0.0 and we get 0.0.0.0. This answer matches the default row Routing table is processed in the order of more octets of 1 set in genmask and genmask 0.0.0.0 is the default route if nothing matches. At the end of this operation Linux figured out that the packet has to be sent to next hop 172.17.0.1 via eth0. The source IP of the packet will be set as the IP of interface eth0. Now to send the packet to 172.17.0.1 linux has to figure out the MAC address of 172.17.0.1. MAC address is figured by looking at the internal arp cache which stores translation between IP address and MAC address. If there is a cache miss, Linux broadcasts ARP request within the internal network asking who has 172.17.0.1. The owner of the IP sends an ARP response which is cached by the kernel and the kernel sends the packet to the gateway by setting Source mac address as mac address of eth0 and destination mac address of 172.17.0.1 which we got just now. Similar routing lookup process is followed in each hop till the packet reaches the actual server. Transport layer and layers above it come to play only at end servers. During intermediate hops only till the IP/Network layer is involved. One weird gateway we saw in the routing table is 0.0.0.0. This gateway means no Layer3(Network layer) hop is needed to send the packet. Both source and destination are in the same network. Kernel has to figure out the mac of the destination and populate source and destination mac appropriately and send the packet out so that it reaches the destination without any Layer3 hop in the middle As we followed in other modules, lets complete this session with SRE usecases","title":"IP Routing and Data Link Layer"},{"location":"level101/linux_networking/ipr/#applications-in-sre-role","text":"Generally the routing table is populated by DHCP and playing around is not a good practice. There can be reasons where one has to play around the routing table but take that path only when it's absolutely necessary Understanding error messages better like, \u201cNo route to host\u201d error can mean mac address of the destination host is not found and it can mean the destination host is down On rare cases looking at the ARP table can help us understand if there is a IP conflict where same IP is assigned to two hosts by mistake and this is causing unexpected behavior","title":"Applications in SRE role"},{"location":"level101/linux_networking/tcp/","text":"TCP TCP is a transport layer protocol like UDP but it guarantees reliability, flow control and congestion control. TCP guarantees reliable delivery by using sequence numbers. A TCP connection is established by a three way handshake. In our case, the client sends a SYN packet along with the starting sequence number it plans to use, the server acknowledges the SYN packet and sends a SYN with its sequence number. Once the client acknowledges the syn packet, the connection is established. Each data transferred from here on is considered delivered reliably once acknowledgement for that sequence is received by the concerned party #To understand handshake run packet capture on one bash session tcpdump -S -i any port 80 #Run curl on one bash session curl www.linkedin.com Here client sends a syn flag shown by [S] flag with a sequence number 1522264672. The server acknowledges receipt of SYN with an ack [.] flag and a Syn flag for its sequence number[S]. The server uses the sequence number 1063230400 and acknowledges the client it\u2019s expecting sequence number 1522264673 (client sequence+1). Client sends a zero length acknowledgement packet to the server(server sequence+1) and connection stands established. This is called three way handshake. The client sends a 76 bytes length packet after this and increments its sequence number by 76. Server sends a 170 byte response and closes the connection. This was the difference we were talking about between HTTP/1.1 and HTTP/1.0. In HTTP/1.1 this same connection can be reused which reduces overhead of 3 way handshake for each HTTP request. If a packet is missed between client and server, server won\u2019t send an ack to the client and client would retry sending the packet till the ACK is received. This guarantees reliability. The flow control is established by the win size field in each segment. The win size says available TCP buffer length in the kernel which can be used to buffer received segments. A size 0 means the receiver has a lot of lag to catch from its socket buffer and the sender has to pause sending packets so that receiver can cope up. This flow control protects from slow receiver and fast sender problem TCP also does congestion control which determines how many segments can be in transit without an ack. Linux provides us the ability to configure algorithms for congestion control which we are not covering here. While closing a connection, client/server calls a close syscall. Let's assume client do that. Client\u2019s kernel will send a FIN packet to the server. Server\u2019s kernel can\u2019t close the connection till the close syscall is called by the server application. Once server app calls close, server also sends a FIN packet and client enters into time wait state for 2*MSS(120s) so that this socket can\u2019t be reused for that time period to prevent any TCP state corruptions due to stray stale packets. Armed with our TCP and HTTP knowledge lets see how this is used by SREs in their role Applications in SRE role Scaling HTTP performance using load balancers need consistent knowledge about both TCP and HTTP. There are different kinds of load balancing like L4, L7 load balancing, Direct Server Return etc. HTTPs offloading can be done on Load balancer or directly on servers based on the performance and compliance needs. Tweaking sysctl variables for rmem and wmem like we did for UDP can improve throughput of sender and receiver. Sysctl variable tcp_max_syn_backlog and socket variable somax_conn determines how many connections for which the kernel can complete 3 way handshake before app calling accept syscall. This is much useful in single threaded applications. Once the backlog is full, new connections stay in SYN_RCVD state (when you run netstat) till the application calls accept syscall Apps can run out of file descriptors if there are too many short lived connections. Digging through tcp_reuse and tcp_recycle can help reduce time spent in the time wait state(it has its own risk). Making apps reuse a pool of connections instead of creating ad hoc connection can also help Understanding performance bottlenecks by seeing metrics and classifying whether its a problem in App or network side. Example too many sockets in Close_wait state is a problem on application whereas retransmissions can be a problem more on network or on OS stack than the application itself. Understanding the fundamentals can help us narrow down where the bottleneck is","title":"TCP"},{"location":"level101/linux_networking/tcp/#tcp","text":"TCP is a transport layer protocol like UDP but it guarantees reliability, flow control and congestion control. TCP guarantees reliable delivery by using sequence numbers. A TCP connection is established by a three way handshake. In our case, the client sends a SYN packet along with the starting sequence number it plans to use, the server acknowledges the SYN packet and sends a SYN with its sequence number. Once the client acknowledges the syn packet, the connection is established. Each data transferred from here on is considered delivered reliably once acknowledgement for that sequence is received by the concerned party #To understand handshake run packet capture on one bash session tcpdump -S -i any port 80 #Run curl on one bash session curl www.linkedin.com Here client sends a syn flag shown by [S] flag with a sequence number 1522264672. The server acknowledges receipt of SYN with an ack [.] flag and a Syn flag for its sequence number[S]. The server uses the sequence number 1063230400 and acknowledges the client it\u2019s expecting sequence number 1522264673 (client sequence+1). Client sends a zero length acknowledgement packet to the server(server sequence+1) and connection stands established. This is called three way handshake. The client sends a 76 bytes length packet after this and increments its sequence number by 76. Server sends a 170 byte response and closes the connection. This was the difference we were talking about between HTTP/1.1 and HTTP/1.0. In HTTP/1.1 this same connection can be reused which reduces overhead of 3 way handshake for each HTTP request. If a packet is missed between client and server, server won\u2019t send an ack to the client and client would retry sending the packet till the ACK is received. This guarantees reliability. The flow control is established by the win size field in each segment. The win size says available TCP buffer length in the kernel which can be used to buffer received segments. A size 0 means the receiver has a lot of lag to catch from its socket buffer and the sender has to pause sending packets so that receiver can cope up. This flow control protects from slow receiver and fast sender problem TCP also does congestion control which determines how many segments can be in transit without an ack. Linux provides us the ability to configure algorithms for congestion control which we are not covering here. While closing a connection, client/server calls a close syscall. Let's assume client do that. Client\u2019s kernel will send a FIN packet to the server. Server\u2019s kernel can\u2019t close the connection till the close syscall is called by the server application. Once server app calls close, server also sends a FIN packet and client enters into time wait state for 2*MSS(120s) so that this socket can\u2019t be reused for that time period to prevent any TCP state corruptions due to stray stale packets. Armed with our TCP and HTTP knowledge lets see how this is used by SREs in their role","title":"TCP"},{"location":"level101/linux_networking/tcp/#applications-in-sre-role","text":"Scaling HTTP performance using load balancers need consistent knowledge about both TCP and HTTP. There are different kinds of load balancing like L4, L7 load balancing, Direct Server Return etc. HTTPs offloading can be done on Load balancer or directly on servers based on the performance and compliance needs. Tweaking sysctl variables for rmem and wmem like we did for UDP can improve throughput of sender and receiver. Sysctl variable tcp_max_syn_backlog and socket variable somax_conn determines how many connections for which the kernel can complete 3 way handshake before app calling accept syscall. This is much useful in single threaded applications. Once the backlog is full, new connections stay in SYN_RCVD state (when you run netstat) till the application calls accept syscall Apps can run out of file descriptors if there are too many short lived connections. Digging through tcp_reuse and tcp_recycle can help reduce time spent in the time wait state(it has its own risk). Making apps reuse a pool of connections instead of creating ad hoc connection can also help Understanding performance bottlenecks by seeing metrics and classifying whether its a problem in App or network side. Example too many sockets in Close_wait state is a problem on application whereas retransmissions can be a problem more on network or on OS stack than the application itself. Understanding the fundamentals can help us narrow down where the bottleneck is","title":"Applications in SRE role"},{"location":"level101/linux_networking/udp/","text":"UDP UDP is a transport layer protocol. DNS is an application layer protocol that runs on top of UDP(most of the times). Before jumping into UDP, let's try to understand what an application and transport layer is. DNS protocol is used by a DNS client(eg dig) and DNS server(eg named). The transport layer makes sure the DNS request reaches the DNS server process and similarly the response reaches the DNS client process. Multiple processes can run on a system and they can listen on any ports . DNS servers usually listen on port number 53. When a client makes a DNS request, after filling the necessary application payload, it passes the payload to the kernel via sendto system call. The kernel picks a random port number( >1024 ) as source port number and puts 53 as destination port number and sends the packet to lower layers. When the kernel on server side receives the packet, it checks the port number and queues the packet to the application buffer of the DNS server process which makes a recvfrom system call and reads the packet. This process by the kernel is called multiplexing(combining packets from multiple applications to same lower layers) and demultiplexing(segregating packets from single lower layer to multiple applications). Multiplexing and Demultiplexing is done by the Transport layer. UDP is one of the simplest transport layer protocol and it does only multiplexing and demultiplexing. Another common transport layer protocol TCP does a bunch of other things like reliable communication, flow control and congestion control. UDP is designed to be lightweight and handle communications with little overhead. So it doesn\u2019t do anything beyond multiplexing and demultiplexing. If applications running on top of UDP need any of the features of TCP, they have to implement that in their application This example from python wiki covers a sample UDP client and server where \u201cHello World\u201d is an application payload sent to server listening on port number 5005. The server receives the packet and prints the \u201cHello World\u201d string from the client Applications in SRE role If the underlying network is slow and the UDP layer is unable to queue packets down to the networking layer, sendto syscall from the application will hang till the kernel finds some of its buffer is freed. This can affect the throughput of the system. Increasing write memory buffer values using sysctl variables net.core.wmem_max and net.core.wmem_default provides some cushion to the application from the slow network Similarly if the receiver process is slow in consuming from its buffer, the kernel has to drop packets which it can\u2019t queue due to the buffer being full. Since UDP doesn\u2019t guarantee reliability these dropped packets can cause data loss unless tracked by the application layer. Increasing sysctl variables rmem_default and rmem_max can provide some cushion to slow applications from fast senders.","title":"UDP"},{"location":"level101/linux_networking/udp/#udp","text":"UDP is a transport layer protocol. DNS is an application layer protocol that runs on top of UDP(most of the times). Before jumping into UDP, let's try to understand what an application and transport layer is. DNS protocol is used by a DNS client(eg dig) and DNS server(eg named). The transport layer makes sure the DNS request reaches the DNS server process and similarly the response reaches the DNS client process. Multiple processes can run on a system and they can listen on any ports . DNS servers usually listen on port number 53. When a client makes a DNS request, after filling the necessary application payload, it passes the payload to the kernel via sendto system call. The kernel picks a random port number( >1024 ) as source port number and puts 53 as destination port number and sends the packet to lower layers. When the kernel on server side receives the packet, it checks the port number and queues the packet to the application buffer of the DNS server process which makes a recvfrom system call and reads the packet. This process by the kernel is called multiplexing(combining packets from multiple applications to same lower layers) and demultiplexing(segregating packets from single lower layer to multiple applications). Multiplexing and Demultiplexing is done by the Transport layer. UDP is one of the simplest transport layer protocol and it does only multiplexing and demultiplexing. Another common transport layer protocol TCP does a bunch of other things like reliable communication, flow control and congestion control. UDP is designed to be lightweight and handle communications with little overhead. So it doesn\u2019t do anything beyond multiplexing and demultiplexing. If applications running on top of UDP need any of the features of TCP, they have to implement that in their application This example from python wiki covers a sample UDP client and server where \u201cHello World\u201d is an application payload sent to server listening on port number 5005. The server receives the packet and prints the \u201cHello World\u201d string from the client","title":"UDP"},{"location":"level101/linux_networking/udp/#applications-in-sre-role","text":"If the underlying network is slow and the UDP layer is unable to queue packets down to the networking layer, sendto syscall from the application will hang till the kernel finds some of its buffer is freed. This can affect the throughput of the system. Increasing write memory buffer values using sysctl variables net.core.wmem_max and net.core.wmem_default provides some cushion to the application from the slow network Similarly if the receiver process is slow in consuming from its buffer, the kernel has to drop packets which it can\u2019t queue due to the buffer being full. Since UDP doesn\u2019t guarantee reliability these dropped packets can cause data loss unless tracked by the application layer. Increasing sysctl variables rmem_default and rmem_max can provide some cushion to slow applications from fast senders.","title":"Applications in SRE role"},{"location":"level101/metrics_and_monitoring/alerts/","text":"Proactive monitoring using alerts Earlier we discussed different ways to collect key metric data points from a service and its underlying infrastructure. This data gives us a better understanding of how the service is performing. One of the main objectives of monitoring is to detect any service degradations early (reduce Mean Time To Detect) and notify stakeholders so that the issues are either avoided or can be fixed early, thus reducing Mean Time To Recover (MTTR). For example, if you are notified when resource usage by a service exceeds 90 percent, you can take preventive measures to avoid any service breakdown due to a shortage of resources. On the other hand, when a service goes down due to an issue, early detection and notification of such incidents can help you quickly fix the issue. Figure 8: An alert notification received on Slack Today most of the monitoring services available provide a mechanism to set up alerts on one or a combination of metrics to actively monitor the service health. These alerts have a set of defined rules or conditions, and when the rule is broken, you are notified. These rules can be as simple as notifying when the metric value exceeds n to as complex as a week over week (WoW) comparison of standard deviation over a period of time. Monitoring tools notify you about an active alert, and most of these tools support instant messaging (IM) platforms, SMS, email, or phone calls. Figure 8 shows a sample alert notification received on Slack for memory usage exceeding 90 percent of total RAM space on the host.","title":"Proactive Monitoring with Alerts"},{"location":"level101/metrics_and_monitoring/alerts/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/alerts/#proactive-monitoring-using-alerts","text":"Earlier we discussed different ways to collect key metric data points from a service and its underlying infrastructure. This data gives us a better understanding of how the service is performing. One of the main objectives of monitoring is to detect any service degradations early (reduce Mean Time To Detect) and notify stakeholders so that the issues are either avoided or can be fixed early, thus reducing Mean Time To Recover (MTTR). For example, if you are notified when resource usage by a service exceeds 90 percent, you can take preventive measures to avoid any service breakdown due to a shortage of resources. On the other hand, when a service goes down due to an issue, early detection and notification of such incidents can help you quickly fix the issue. Figure 8: An alert notification received on Slack Today most of the monitoring services available provide a mechanism to set up alerts on one or a combination of metrics to actively monitor the service health. These alerts have a set of defined rules or conditions, and when the rule is broken, you are notified. These rules can be as simple as notifying when the metric value exceeds n to as complex as a week over week (WoW) comparison of standard deviation over a period of time. Monitoring tools notify you about an active alert, and most of these tools support instant messaging (IM) platforms, SMS, email, or phone calls. Figure 8 shows a sample alert notification received on Slack for memory usage exceeding 90 percent of total RAM space on the host.","title":"Proactive monitoring using alerts"},{"location":"level101/metrics_and_monitoring/best_practices/","text":"Best practices for monitoring When setting up monitoring for a service, keep the following best practices in mind. Use the right metric type -- Most of the libraries available today offer various metric types. Choose the appropriate metric type for monitoring your system. Following are the types of metrics and their purposes. Gauge -- Gauge is a constant type of metric. After the metric is initialized, the metric value does not change unless you intentionally update it. Timer -- Timer measures the time taken to complete a task. Counter -- Counter counts the number of occurrences of a particular event. For more information about these metric types, see Data Types . Avoid over-monitoring -- Monitoring can be a significant engineering endeavor . Therefore, be sure not to spend too much time and resources on monitoring services, yet make sure all important metrics are captured. Prevent alert fatigue -- Set alerts for metrics that are important and actionable. If you receive too many non-critical alerts, you might start ignoring alert notifications over time. As a result, critical alerts might get overlooked. Have a runbook for alerts -- For every alert, make sure you have a document explaining what actions and checks need to be performed when the alert fires. This enables any engineer on the team to handle the alert and take necessary actions, without any help from others.","title":"Best Practices for Monitoring"},{"location":"level101/metrics_and_monitoring/best_practices/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/best_practices/#best-practices-for-monitoring","text":"When setting up monitoring for a service, keep the following best practices in mind. Use the right metric type -- Most of the libraries available today offer various metric types. Choose the appropriate metric type for monitoring your system. Following are the types of metrics and their purposes. Gauge -- Gauge is a constant type of metric. After the metric is initialized, the metric value does not change unless you intentionally update it. Timer -- Timer measures the time taken to complete a task. Counter -- Counter counts the number of occurrences of a particular event. For more information about these metric types, see Data Types . Avoid over-monitoring -- Monitoring can be a significant engineering endeavor . Therefore, be sure not to spend too much time and resources on monitoring services, yet make sure all important metrics are captured. Prevent alert fatigue -- Set alerts for metrics that are important and actionable. If you receive too many non-critical alerts, you might start ignoring alert notifications over time. As a result, critical alerts might get overlooked. Have a runbook for alerts -- For every alert, make sure you have a document explaining what actions and checks need to be performed when the alert fires. This enables any engineer on the team to handle the alert and take necessary actions, without any help from others.","title":"Best practices for monitoring"},{"location":"level101/metrics_and_monitoring/command-line_tools/","text":"Command-line tools Most of the Linux distributions today come with a set of tools that monitor the system's performance. These tools help you measure and understand various subsystem statistics (CPU, memory, network, and so on). Let's look at some of the tools that are predominantly used. ps/top -- The process status command (ps) displays information about all the currently running processes in a Linux system. The top command is similar to the ps command, but it periodically updates the information displayed until the program is terminated. An advanced version of top, called htop, has a more user-friendly interface and some additional features. These command-line utilities come with options to modify the operation and output of the command. Following are some important options supported by the ps command. -p -- Displays information about processes that match the specified process IDs. Similarly, you can use -u and -g to display information about processes belonging to a specific user or group. -a -- Displays information about other users' processes, as well as one's own. -x -- When displaying processes matched by other options, includes processes that do not have a controlling terminal. Figure 2: Results of top command ss -- The socket statistics command (ss) displays information about network sockets on the system. This tool is the successor of netstat , which is deprecated. Following are some command-line options supported by the ss command: -t -- Displays the TCP socket. Similarly, -u displays UDP sockets, -x is for UNIX domain sockets, and so on. -l -- Displays only listening sockets. -n -- Instructs the command to not resolve service names. Instead displays the port numbers. Figure 3: List of listening sockets on a system free -- The free command displays memory usage statistics on the host like available memory, used memory, and free memory. Most often, this command is used with the -h command-line option, which displays the statistics in a human-readable format. Figure 4: Memory statistics on a host in human-readable form df -- The df command displays disk space usage statistics. The -i command-line option is also often used to display inode usage statistics. The -h command-line option is used for displaying statistics in a human-readable format. Figure 5: Disk usage statistics on a system in human-readable form sar -- The sar utility monitors various subsystems, such as CPU and memory, in real time. This data can be stored in a file specified with the -o option. This tool helps to identify anomalies. iftop -- The interface top command ( iftop ) displays bandwidth utilization by a host on an interface. This command is often used to identify bandwidth usage by active connections. The -i option specifies which network interface to watch. Figure 6: Network bandwidth usage by active connection on the host tcpdump -- The tcpdump command is a network monitoring tool that captures network packets flowing over the network and displays a description of the captured packets. The following options are available: -i -- Interface to listen on host -- Filters traffic going to or from the specified host src/dst -- Displays one-way traffic from the source (src) or to the destination (dst) port -- Filters traffic to or from a particular port Figure 7: *tcpdump* of packets on *docker0* interface on a host","title":"Command-line Tools"},{"location":"level101/metrics_and_monitoring/command-line_tools/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/command-line_tools/#command-line-tools","text":"Most of the Linux distributions today come with a set of tools that monitor the system's performance. These tools help you measure and understand various subsystem statistics (CPU, memory, network, and so on). Let's look at some of the tools that are predominantly used. ps/top -- The process status command (ps) displays information about all the currently running processes in a Linux system. The top command is similar to the ps command, but it periodically updates the information displayed until the program is terminated. An advanced version of top, called htop, has a more user-friendly interface and some additional features. These command-line utilities come with options to modify the operation and output of the command. Following are some important options supported by the ps command. -p -- Displays information about processes that match the specified process IDs. Similarly, you can use -u and -g to display information about processes belonging to a specific user or group. -a -- Displays information about other users' processes, as well as one's own. -x -- When displaying processes matched by other options, includes processes that do not have a controlling terminal. Figure 2: Results of top command ss -- The socket statistics command (ss) displays information about network sockets on the system. This tool is the successor of netstat , which is deprecated. Following are some command-line options supported by the ss command: -t -- Displays the TCP socket. Similarly, -u displays UDP sockets, -x is for UNIX domain sockets, and so on. -l -- Displays only listening sockets. -n -- Instructs the command to not resolve service names. Instead displays the port numbers. Figure 3: List of listening sockets on a system free -- The free command displays memory usage statistics on the host like available memory, used memory, and free memory. Most often, this command is used with the -h command-line option, which displays the statistics in a human-readable format. Figure 4: Memory statistics on a host in human-readable form df -- The df command displays disk space usage statistics. The -i command-line option is also often used to display inode usage statistics. The -h command-line option is used for displaying statistics in a human-readable format. Figure 5: Disk usage statistics on a system in human-readable form sar -- The sar utility monitors various subsystems, such as CPU and memory, in real time. This data can be stored in a file specified with the -o option. This tool helps to identify anomalies. iftop -- The interface top command ( iftop ) displays bandwidth utilization by a host on an interface. This command is often used to identify bandwidth usage by active connections. The -i option specifies which network interface to watch. Figure 6: Network bandwidth usage by active connection on the host tcpdump -- The tcpdump command is a network monitoring tool that captures network packets flowing over the network and displays a description of the captured packets. The following options are available: -i -- Interface to listen on host -- Filters traffic going to or from the specified host src/dst -- Displays one-way traffic from the source (src) or to the destination (dst) port -- Filters traffic to or from a particular port Figure 7: *tcpdump* of packets on *docker0* interface on a host","title":"Command-line tools"},{"location":"level101/metrics_and_monitoring/conclusion/","text":"Conclusion A robust monitoring and alerting system is necessary for maintaining and troubleshooting a system. A dashboard with key metrics can give you an overview of service performance, all in one place. Well-defined alerts (with realistic thresholds and notifications) further enable you to quickly identify any anomalies in the service infrastructure and in resource saturation. By taking necessary actions, you can avoid any service degradations and decrease MTTD for service breakdowns. In addition to in-house monitoring, monitoring real user experience can help you to understand service performance as perceived by the users. Many modules are involved in serving the user, and most of them are out of your control. Therefore, you need to have real-user monitoring in place. Metrics give very abstract details on service performance. To get a better understanding of the system and for faster recovery during incidents, you might want to implement the other two pillars of observability: logs and tracing. Logs and trace data can help you understand what led to service failure or degradation. Following are some resources to learn more about monitoring and observability: Google SRE book: Monitoring Distributed Systems Mastering Distributed Tracing by Yuri Shkuro References Google SRE book: Monitoring Distributed Systems Mastering Distributed Tracing, by Yuri Shkuro Monitoring and Observability Three PIllars with Zero Answers Engineering blogs on LinkedIn , Grafana , Elastic.co , OpenTelemetry","title":"Conclusion"},{"location":"level101/metrics_and_monitoring/conclusion/#conclusion","text":"A robust monitoring and alerting system is necessary for maintaining and troubleshooting a system. A dashboard with key metrics can give you an overview of service performance, all in one place. Well-defined alerts (with realistic thresholds and notifications) further enable you to quickly identify any anomalies in the service infrastructure and in resource saturation. By taking necessary actions, you can avoid any service degradations and decrease MTTD for service breakdowns. In addition to in-house monitoring, monitoring real user experience can help you to understand service performance as perceived by the users. Many modules are involved in serving the user, and most of them are out of your control. Therefore, you need to have real-user monitoring in place. Metrics give very abstract details on service performance. To get a better understanding of the system and for faster recovery during incidents, you might want to implement the other two pillars of observability: logs and tracing. Logs and trace data can help you understand what led to service failure or degradation. Following are some resources to learn more about monitoring and observability: Google SRE book: Monitoring Distributed Systems Mastering Distributed Tracing by Yuri Shkuro","title":"Conclusion"},{"location":"level101/metrics_and_monitoring/conclusion/#references","text":"Google SRE book: Monitoring Distributed Systems Mastering Distributed Tracing, by Yuri Shkuro Monitoring and Observability Three PIllars with Zero Answers Engineering blogs on LinkedIn , Grafana , Elastic.co , OpenTelemetry","title":"References"},{"location":"level101/metrics_and_monitoring/introduction/","text":"Prerequisites Linux Basics Python and the Web Systems Design Linux Networking Fundamentals What to expect from this course Monitoring is an integral part of any system. As an SRE, you need to have a basic understanding of monitoring a service infrastructure. By the end of this course, you will gain a better understanding of the following topics: What is monitoring? What needs to be measured How the metrics gathered can be used to improve business decisions and overall reliability Proactive monitoring with alerts Log processing and its importance What is observability? Distributed tracing Logs Metrics What is not covered in this course Guide to setting up a monitoring infrastructure Deep dive into different monitoring technologies and benchmarking or comparison of any tools Course content Introduction Four golden signals of monitoring Why is monitoring important? Command-line tools Third-party monitoring Proactive monitoring using alerts Best practices for monitoring Observability Logs Tracing Conclusion Introduction Monitoring is a process of collecting real-time performance metrics from a system, analyzing the data to derive meaningful information, and displaying the data to the users. In simple terms, you measure various metrics regularly to understand the state of the system, including but not limited to, user requests, latency, and error rate. What gets measured, gets fixed ---if you can measure something, you can reason about it, understand it, discuss it, and act upon it with confidence. Four golden signals of monitoring When setting up monitoring for a system, you need to decide what to measure. The four golden signals of monitoring provide a good understanding of service performance and lay a foundation for monitoring a system. These four golden signals are Traffic Latency Error Saturation These metrics help you to understand the system performance and bottlenecks, and to create a better end-user experience. As discussed in the Google SRE book , if you can measure only four metrics of your service, focus on these four. Let's look at each of the four golden signals. Traffic -- Traffic gives a better understanding of the service demand. Often referred to as service QPS (queries per second), traffic is a measure of requests served by the service. This signal helps you to decide when a service needs to be scaled up to handle increasing customer demand and scaled down to be cost-effective. Latency -- Latency is the measure of time taken by the service to process the incoming request and send the response. Measuring service latency helps in the early detection of slow degradation of the service. Distinguishing between the latency of successful requests and the latency of failed requests is important. For example, an HTTP 5XX error triggered due to loss of connection to a database or other critical backend might be served very quickly. However, because an HTTP 500 error indicates a failed request, factoring 500s into overall latency might result in misleading calculations. Error (rate) -- Error is the measure of failed client requests. These failures can be easily identified based on the response codes ( HTTP 5XX error ). There might be cases where the response is considered erroneous due to wrong result data or due to policy violations. For example, you might get an HTTP 200 response, but the body has incomplete data, or response time is breaching the agreed-upon SLA s. Therefore, you need to have other mechanisms (code logic or instrumentation ) in place to capture errors in addition to the response codes. Saturation -- Saturation is a measure of the resource utilization by a service. This signal tells you the state of service resources and how full they are. These resources include memory, compute, network I/O, and so on. Service performance slowly degrades even before resource utilization is at 100 percent. Therefore, having a utilization target is important. An increase in latency is a good indicator of saturation; measuring the 99th percentile of latency can help in the early detection of saturation. Depending on the type of service, you can measure these signals in different ways. For example, you might measure queries per second served for a web server. In contrast, for a database server, transactions performed and database sessions created give you an idea about the traffic handled by the database server. With the help of additional code logic (monitoring libraries and instrumentation), you can measure these signals periodically and store them for future analysis. Although these metrics give you an idea about the performance at the service end, you need to also ensure that the same user experience is delivered at the client end. Therefore, you might need to monitor the service from outside the service infrastructure, which is discussed under third-party monitoring. Why is monitoring important? Monitoring plays a key role in the success of a service. As discussed earlier, monitoring provides performance insights for understanding service health. With access to historical data collected over time, you can build intelligent applications to address specific needs. Some of the key use cases follow: Reduction in time to resolve issues -- With a good monitoring infrastructure in place, you can identify issues quickly and resolve them, which reduces the impact caused by the issues. Business decisions -- Data collected over a period of time can help you make business decisions such as determining the product release cycle, which features to invest in, and geographical areas to focus on. Decisions based on long-term data can improve the overall product experience. Resource planning -- By analyzing historical data, you can forecast service compute-resource demands, and you can properly allocate resources. This allows financially effective decisions, with no compromise in end-user experience. Before we dive deeper into monitoring, let's understand some basic terminologies. Metric -- A metric is a quantitative measure of a particular system attribute---for example, memory or CPU Node or host -- A physical server, virtual machine, or container where an application is running QPS -- Queries Per Second , a measure of traffic served by the service per second Latency -- The time interval between user action and the response from the server---for example, time spent after sending a query to a database before the first response bit is received Error rate -- Number of errors observed over a particular time period (usually a second) Graph -- In monitoring, a graph is a representation of one or more values of metrics collected over time Dashboard -- A dashboard is a collection of graphs that provide an overview of system health Incident -- An incident is an event that disrupts the normal operations of a system MTTD -- Mean Time To Detect is the time interval between the beginning of a service failure and the detection of such failure MTTR -- Mean Time To Resolve is the time spent to fix a service failure and bring the service back to its normal state Before we discuss monitoring an application, let us look at the monitoring infrastructure. Following is an illustration of a basic monitoring system. Figure 1: Illustration of a monitoring infrastructure Figure 1 shows a monitoring infrastructure mechanism for aggregating metrics on the system, and collecting and storing the data for display. In addition, a monitoring infrastructure includes alert subsystems for notifying concerned parties during any abnormal behavior. Let's look at each of these infrastructure components: Host metrics agent -- A host metrics agent is a process running on the host that collects performance statistics for host subsystems such as memory, CPU, and network. These metrics are regularly relayed to a metrics collector for storage and visualization. Some examples are collectd , telegraf , and metricbeat . Metric aggregator -- A metric aggregator is a process running on the host. Applications running on the host collect service metrics using instrumentation . Collected metrics are sent either to the aggregator process or directly to the metrics collector over API, if available. Received metrics are aggregated periodically and relayed to the metrics collector in batches. An example is StatsD . Metrics collector -- A metrics collector process collects all the metrics from the metric aggregators running on multiple hosts. The collector takes care of decoding and stores this data on the database. Metric collection and storage might be taken care of by one single service such as InfluxDB , which we discuss next. An example is carbon daemons . Storage -- A time-series database stores all of these metrics. Examples are OpenTSDB , Whisper , and InfluxDB . Metrics server -- A metrics server can be as basic as a web server that graphically renders metric data. In addition, the metrics server provides aggregation functionalities and APIs for fetching metric data programmatically. Some examples are Grafana and Graphite-Web . Alert manager -- The alert manager regularly polls metric data available and, if there are any anomalies detected, notifies you. Each alert has a set of rules for identifying such anomalies. Today many metrics servers such as Grafana support alert management. We discuss alerting in detail later . Examples are Grafana and Icinga .","title":"Introduction"},{"location":"level101/metrics_and_monitoring/introduction/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/introduction/#prerequisites","text":"Linux Basics Python and the Web Systems Design Linux Networking Fundamentals","title":"Prerequisites"},{"location":"level101/metrics_and_monitoring/introduction/#what-to-expect-from-this-course","text":"Monitoring is an integral part of any system. As an SRE, you need to have a basic understanding of monitoring a service infrastructure. By the end of this course, you will gain a better understanding of the following topics: What is monitoring? What needs to be measured How the metrics gathered can be used to improve business decisions and overall reliability Proactive monitoring with alerts Log processing and its importance What is observability? Distributed tracing Logs Metrics","title":"What to expect from this course"},{"location":"level101/metrics_and_monitoring/introduction/#what-is-not-covered-in-this-course","text":"Guide to setting up a monitoring infrastructure Deep dive into different monitoring technologies and benchmarking or comparison of any tools","title":"What is not covered in this course"},{"location":"level101/metrics_and_monitoring/introduction/#course-content","text":"Introduction Four golden signals of monitoring Why is monitoring important? Command-line tools Third-party monitoring Proactive monitoring using alerts Best practices for monitoring Observability Logs Tracing Conclusion","title":"Course content"},{"location":"level101/metrics_and_monitoring/introduction/#_2","text":"","title":""},{"location":"level101/metrics_and_monitoring/introduction/#introduction","text":"Monitoring is a process of collecting real-time performance metrics from a system, analyzing the data to derive meaningful information, and displaying the data to the users. In simple terms, you measure various metrics regularly to understand the state of the system, including but not limited to, user requests, latency, and error rate. What gets measured, gets fixed ---if you can measure something, you can reason about it, understand it, discuss it, and act upon it with confidence.","title":"Introduction"},{"location":"level101/metrics_and_monitoring/introduction/#four-golden-signals-of-monitoring","text":"When setting up monitoring for a system, you need to decide what to measure. The four golden signals of monitoring provide a good understanding of service performance and lay a foundation for monitoring a system. These four golden signals are Traffic Latency Error Saturation These metrics help you to understand the system performance and bottlenecks, and to create a better end-user experience. As discussed in the Google SRE book , if you can measure only four metrics of your service, focus on these four. Let's look at each of the four golden signals. Traffic -- Traffic gives a better understanding of the service demand. Often referred to as service QPS (queries per second), traffic is a measure of requests served by the service. This signal helps you to decide when a service needs to be scaled up to handle increasing customer demand and scaled down to be cost-effective. Latency -- Latency is the measure of time taken by the service to process the incoming request and send the response. Measuring service latency helps in the early detection of slow degradation of the service. Distinguishing between the latency of successful requests and the latency of failed requests is important. For example, an HTTP 5XX error triggered due to loss of connection to a database or other critical backend might be served very quickly. However, because an HTTP 500 error indicates a failed request, factoring 500s into overall latency might result in misleading calculations. Error (rate) -- Error is the measure of failed client requests. These failures can be easily identified based on the response codes ( HTTP 5XX error ). There might be cases where the response is considered erroneous due to wrong result data or due to policy violations. For example, you might get an HTTP 200 response, but the body has incomplete data, or response time is breaching the agreed-upon SLA s. Therefore, you need to have other mechanisms (code logic or instrumentation ) in place to capture errors in addition to the response codes. Saturation -- Saturation is a measure of the resource utilization by a service. This signal tells you the state of service resources and how full they are. These resources include memory, compute, network I/O, and so on. Service performance slowly degrades even before resource utilization is at 100 percent. Therefore, having a utilization target is important. An increase in latency is a good indicator of saturation; measuring the 99th percentile of latency can help in the early detection of saturation. Depending on the type of service, you can measure these signals in different ways. For example, you might measure queries per second served for a web server. In contrast, for a database server, transactions performed and database sessions created give you an idea about the traffic handled by the database server. With the help of additional code logic (monitoring libraries and instrumentation), you can measure these signals periodically and store them for future analysis. Although these metrics give you an idea about the performance at the service end, you need to also ensure that the same user experience is delivered at the client end. Therefore, you might need to monitor the service from outside the service infrastructure, which is discussed under third-party monitoring.","title":"Four golden signals of monitoring"},{"location":"level101/metrics_and_monitoring/introduction/#why-is-monitoring-important","text":"Monitoring plays a key role in the success of a service. As discussed earlier, monitoring provides performance insights for understanding service health. With access to historical data collected over time, you can build intelligent applications to address specific needs. Some of the key use cases follow: Reduction in time to resolve issues -- With a good monitoring infrastructure in place, you can identify issues quickly and resolve them, which reduces the impact caused by the issues. Business decisions -- Data collected over a period of time can help you make business decisions such as determining the product release cycle, which features to invest in, and geographical areas to focus on. Decisions based on long-term data can improve the overall product experience. Resource planning -- By analyzing historical data, you can forecast service compute-resource demands, and you can properly allocate resources. This allows financially effective decisions, with no compromise in end-user experience. Before we dive deeper into monitoring, let's understand some basic terminologies. Metric -- A metric is a quantitative measure of a particular system attribute---for example, memory or CPU Node or host -- A physical server, virtual machine, or container where an application is running QPS -- Queries Per Second , a measure of traffic served by the service per second Latency -- The time interval between user action and the response from the server---for example, time spent after sending a query to a database before the first response bit is received Error rate -- Number of errors observed over a particular time period (usually a second) Graph -- In monitoring, a graph is a representation of one or more values of metrics collected over time Dashboard -- A dashboard is a collection of graphs that provide an overview of system health Incident -- An incident is an event that disrupts the normal operations of a system MTTD -- Mean Time To Detect is the time interval between the beginning of a service failure and the detection of such failure MTTR -- Mean Time To Resolve is the time spent to fix a service failure and bring the service back to its normal state Before we discuss monitoring an application, let us look at the monitoring infrastructure. Following is an illustration of a basic monitoring system. Figure 1: Illustration of a monitoring infrastructure Figure 1 shows a monitoring infrastructure mechanism for aggregating metrics on the system, and collecting and storing the data for display. In addition, a monitoring infrastructure includes alert subsystems for notifying concerned parties during any abnormal behavior. Let's look at each of these infrastructure components: Host metrics agent -- A host metrics agent is a process running on the host that collects performance statistics for host subsystems such as memory, CPU, and network. These metrics are regularly relayed to a metrics collector for storage and visualization. Some examples are collectd , telegraf , and metricbeat . Metric aggregator -- A metric aggregator is a process running on the host. Applications running on the host collect service metrics using instrumentation . Collected metrics are sent either to the aggregator process or directly to the metrics collector over API, if available. Received metrics are aggregated periodically and relayed to the metrics collector in batches. An example is StatsD . Metrics collector -- A metrics collector process collects all the metrics from the metric aggregators running on multiple hosts. The collector takes care of decoding and stores this data on the database. Metric collection and storage might be taken care of by one single service such as InfluxDB , which we discuss next. An example is carbon daemons . Storage -- A time-series database stores all of these metrics. Examples are OpenTSDB , Whisper , and InfluxDB . Metrics server -- A metrics server can be as basic as a web server that graphically renders metric data. In addition, the metrics server provides aggregation functionalities and APIs for fetching metric data programmatically. Some examples are Grafana and Graphite-Web . Alert manager -- The alert manager regularly polls metric data available and, if there are any anomalies detected, notifies you. Each alert has a set of rules for identifying such anomalies. Today many metrics servers such as Grafana support alert management. We discuss alerting in detail later . Examples are Grafana and Icinga .","title":"Why is monitoring important?"},{"location":"level101/metrics_and_monitoring/observability/","text":"Observability Engineers often use observability when referring to building reliable systems. Observability is a term derived from control theory, It is a measure of how well internal states of a system can be inferred from knowledge of its external outputs. Service infrastructures used on a daily basis are becoming more and more complex; proactive monitoring alone is not sufficient to quickly resolve issues causing application failures. With monitoring, you can keep known past failures from recurring, but with a complex service architecture, many unknown factors can cause potential problems. To address such cases, you can make the service observable. An observable system provides highly granular insights into the implicit failure modes. In addition, an observable system furnishes ample context about its inner workings, which unlocks the ability to uncover deeper systemic issues. Monitoring enables failure detection; observability helps in gaining a better understanding of the system. Among engineers, there is a common misconception that monitoring and observability are two different things. Actually, observability is the superset to monitoring; that is, monitoring improves service observability. The goal of observability is not only to detect problems, but also to understand where the issue is and what is causing it. In addition to metrics, observability has two more pillars: logs and traces, as shown in Figure 9. Although these three components do not make a system 100 percent observable, these are the most important and powerful components that give a better understanding of the system. Each of these pillars has its flaws, which are described in Three Pillars with Zero Answers . Figure 9: Three pillars of observability Because we have covered metrics already, let's look at the other two pillars (logs and traces). Logs Logs (often referred to as events ) are a record of activities performed by a service during its run time, with a corresponding timestamp. Metrics give abstract information about degradations in a system, and logs give a detailed view of what is causing these degradations. Logs created by the applications and infrastructure components help in effectively understanding the behavior of the system by providing details on application errors, exceptions, and event timelines. Logs help you to go back in time to understand the events that led to a failure. Therefore, examining logs is essential to troubleshooting system failures. Log processing involves the aggregation of different logs from individual applications and their subsequent shipment to central storage. Moving logs to central storage helps to preserve the logs, in case the application instances are inaccessible, or the application crashes due to a failure. After the logs are available in a central place, you can analyze the logs to derive sensible information from them. For audit and compliance purposes, you archive these logs on the central storage for a certain period of time. Log analyzers fetch useful information from log lines, such as request user information, request URL (feature), and response headers (such as content length) and response time. This information is grouped based on these attributes and made available to you through a visualization tool for quick understanding. You might be wondering how this log information helps. This information gives a holistic view of activities performed on all the involved entities. For example, let's say someone is performing a DoS (denial of service) attack on a web application. With the help of log processing, you can quickly look at top client IPs derived from access logs and identify where the attack is coming from. Similarly, if a feature in an application is causing a high error rate when accessed with a particular request parameter value, the results of log analysis can help you to quickly identify the misbehaving parameter value and take further action. Figure 10: Log processing and analysis using ELK stack Figure 10 shows a log processing platform using ELK (Elasticsearch, Logstash, Kibana), which provides centralized log processing. Beats is a collection of lightweight data shippers that can ship logs, audit data, network data, and so on over the network. In this use case specifically, we are using filebeat as a log shipper. Filebeat watches service log files and ships the log data to Logstash. Logstash parses these logs and transforms the data, preparing it to store on Elasticsearch. Transformed log data is stored on Elasticsearch and indexed for fast retrieval. Kibana searches and displays log data stored on Elasticsearch. Kibana also provides a set of visualizations for graphically displaying summaries derived from log data. Storing logs is expensive. And extensive logging of every event on the server is costly and takes up more storage space. With an increasing number of services, this cost can increase proportionally to the number of services. Tracing So far, we covered the importance of metrics and logging. Metrics give an abstract overview of the system, and logging gives a record of events that occurred. Imagine a complex distributed system with multiple microservices, where a user request is processed by multiple microservices in the system. Metrics and logging give you some information about how these requests are being handled by the system, but they fail to provide detailed information across all the microservices and how they affect a particular client request. If a slow downstream microservice is leading to increased response times, you need to have detailed visibility across all involved microservices to identify such microservice. The answer to this need is a request tracing mechanism. A trace is a series of spans, where each span is a record of events performed by different microservices to serve the client's request. In simple terms, a trace is a log of client-request serving derived from various microservices across different physical machines. Each span includes span metadata such as trace ID and span ID, and context, which includes information about transactions performed. Figure 11: Trace and spans for a URL shortener request Figure 11 is a graphical representation of a trace captured on the URL shortener example we covered earlier while learning Python. Similar to monitoring, the tracing infrastructure comprises a few modules for collecting traces, storing them, and accessing them. Each microservice runs a tracing library that collects traces in the background, creates in-memory batches, and submits the tracing backend. The tracing backend normalizes received trace data and stores it on persistent storage. Tracing data comes from multiple different microservices; therefore, trace storage is often organized to store data incrementally and is indexed by trace identifier. This organization helps in the reconstruction of trace data and in visualization. Figure 12 illustrates the anatomy of the distributed system. Figure 12: Anatomy of distributed tracing Today a set of tools and frameworks are available for building distributed tracing solutions. Following are some of the popular tools: OpenTelemetry : Observability framework for cloud-native software Jaeger : Open-source distributed tracing solution Zipkin : Open-source distributed tracing solution","title":"Observability"},{"location":"level101/metrics_and_monitoring/observability/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/observability/#observability","text":"Engineers often use observability when referring to building reliable systems. Observability is a term derived from control theory, It is a measure of how well internal states of a system can be inferred from knowledge of its external outputs. Service infrastructures used on a daily basis are becoming more and more complex; proactive monitoring alone is not sufficient to quickly resolve issues causing application failures. With monitoring, you can keep known past failures from recurring, but with a complex service architecture, many unknown factors can cause potential problems. To address such cases, you can make the service observable. An observable system provides highly granular insights into the implicit failure modes. In addition, an observable system furnishes ample context about its inner workings, which unlocks the ability to uncover deeper systemic issues. Monitoring enables failure detection; observability helps in gaining a better understanding of the system. Among engineers, there is a common misconception that monitoring and observability are two different things. Actually, observability is the superset to monitoring; that is, monitoring improves service observability. The goal of observability is not only to detect problems, but also to understand where the issue is and what is causing it. In addition to metrics, observability has two more pillars: logs and traces, as shown in Figure 9. Although these three components do not make a system 100 percent observable, these are the most important and powerful components that give a better understanding of the system. Each of these pillars has its flaws, which are described in Three Pillars with Zero Answers . Figure 9: Three pillars of observability Because we have covered metrics already, let's look at the other two pillars (logs and traces).","title":"Observability"},{"location":"level101/metrics_and_monitoring/observability/#logs","text":"Logs (often referred to as events ) are a record of activities performed by a service during its run time, with a corresponding timestamp. Metrics give abstract information about degradations in a system, and logs give a detailed view of what is causing these degradations. Logs created by the applications and infrastructure components help in effectively understanding the behavior of the system by providing details on application errors, exceptions, and event timelines. Logs help you to go back in time to understand the events that led to a failure. Therefore, examining logs is essential to troubleshooting system failures. Log processing involves the aggregation of different logs from individual applications and their subsequent shipment to central storage. Moving logs to central storage helps to preserve the logs, in case the application instances are inaccessible, or the application crashes due to a failure. After the logs are available in a central place, you can analyze the logs to derive sensible information from them. For audit and compliance purposes, you archive these logs on the central storage for a certain period of time. Log analyzers fetch useful information from log lines, such as request user information, request URL (feature), and response headers (such as content length) and response time. This information is grouped based on these attributes and made available to you through a visualization tool for quick understanding. You might be wondering how this log information helps. This information gives a holistic view of activities performed on all the involved entities. For example, let's say someone is performing a DoS (denial of service) attack on a web application. With the help of log processing, you can quickly look at top client IPs derived from access logs and identify where the attack is coming from. Similarly, if a feature in an application is causing a high error rate when accessed with a particular request parameter value, the results of log analysis can help you to quickly identify the misbehaving parameter value and take further action. Figure 10: Log processing and analysis using ELK stack Figure 10 shows a log processing platform using ELK (Elasticsearch, Logstash, Kibana), which provides centralized log processing. Beats is a collection of lightweight data shippers that can ship logs, audit data, network data, and so on over the network. In this use case specifically, we are using filebeat as a log shipper. Filebeat watches service log files and ships the log data to Logstash. Logstash parses these logs and transforms the data, preparing it to store on Elasticsearch. Transformed log data is stored on Elasticsearch and indexed for fast retrieval. Kibana searches and displays log data stored on Elasticsearch. Kibana also provides a set of visualizations for graphically displaying summaries derived from log data. Storing logs is expensive. And extensive logging of every event on the server is costly and takes up more storage space. With an increasing number of services, this cost can increase proportionally to the number of services.","title":"Logs"},{"location":"level101/metrics_and_monitoring/observability/#tracing","text":"So far, we covered the importance of metrics and logging. Metrics give an abstract overview of the system, and logging gives a record of events that occurred. Imagine a complex distributed system with multiple microservices, where a user request is processed by multiple microservices in the system. Metrics and logging give you some information about how these requests are being handled by the system, but they fail to provide detailed information across all the microservices and how they affect a particular client request. If a slow downstream microservice is leading to increased response times, you need to have detailed visibility across all involved microservices to identify such microservice. The answer to this need is a request tracing mechanism. A trace is a series of spans, where each span is a record of events performed by different microservices to serve the client's request. In simple terms, a trace is a log of client-request serving derived from various microservices across different physical machines. Each span includes span metadata such as trace ID and span ID, and context, which includes information about transactions performed. Figure 11: Trace and spans for a URL shortener request Figure 11 is a graphical representation of a trace captured on the URL shortener example we covered earlier while learning Python. Similar to monitoring, the tracing infrastructure comprises a few modules for collecting traces, storing them, and accessing them. Each microservice runs a tracing library that collects traces in the background, creates in-memory batches, and submits the tracing backend. The tracing backend normalizes received trace data and stores it on persistent storage. Tracing data comes from multiple different microservices; therefore, trace storage is often organized to store data incrementally and is indexed by trace identifier. This organization helps in the reconstruction of trace data and in visualization. Figure 12 illustrates the anatomy of the distributed system. Figure 12: Anatomy of distributed tracing Today a set of tools and frameworks are available for building distributed tracing solutions. Following are some of the popular tools: OpenTelemetry : Observability framework for cloud-native software Jaeger : Open-source distributed tracing solution Zipkin : Open-source distributed tracing solution","title":"Tracing"},{"location":"level101/metrics_and_monitoring/third-party_monitoring/","text":"Third-party monitoring Today most cloud providers offer a variety of monitoring solutions. In addition, a number of companies such as Datadog offer monitoring-as-a-service. In this section, we are not covering monitoring-as-a-service in depth. In recent years, more and more people have access to the internet. Many services are offered online to cater to the increasing user base. As a result, web pages are becoming larger, with increased client-side scripts. Users want these services to be fast and error-free. From the service point of view, when the response body is composed, an HTTP 200 OK response is sent, and everything looks okay. But there might be errors during transmission or on the client side. As previously mentioned, monitoring services from within the service infrastructure give good visibility into service health, but this is not enough. You need to monitor user experience, specifically the availability of services for clients. A number of third-party services such asf Catchpoint , Pingdom , and so on are available for achieving this goal. Third-party monitoring services can generate synthetic traffic simulating user requests from various parts of the world, to ensure the service is globally accessible. Other third-party monitoring solutions for real user monitoring (RUM) provide performance statistics such as service uptime and response time, from different geographical locations. This allows you to monitor the user experience from these locations, which might have different internet backbones, different operating systems, and different browsers and browser versions. Catchpoint Global Monitoring Network is a comprehensive 3-minute video that explains the importance of monitoring the client experience.","title":"Third-party Monitoring"},{"location":"level101/metrics_and_monitoring/third-party_monitoring/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/third-party_monitoring/#third-party-monitoring","text":"Today most cloud providers offer a variety of monitoring solutions. In addition, a number of companies such as Datadog offer monitoring-as-a-service. In this section, we are not covering monitoring-as-a-service in depth. In recent years, more and more people have access to the internet. Many services are offered online to cater to the increasing user base. As a result, web pages are becoming larger, with increased client-side scripts. Users want these services to be fast and error-free. From the service point of view, when the response body is composed, an HTTP 200 OK response is sent, and everything looks okay. But there might be errors during transmission or on the client side. As previously mentioned, monitoring services from within the service infrastructure give good visibility into service health, but this is not enough. You need to monitor user experience, specifically the availability of services for clients. A number of third-party services such asf Catchpoint , Pingdom , and so on are available for achieving this goal. Third-party monitoring services can generate synthetic traffic simulating user requests from various parts of the world, to ensure the service is globally accessible. Other third-party monitoring solutions for real user monitoring (RUM) provide performance statistics such as service uptime and response time, from different geographical locations. This allows you to monitor the user experience from these locations, which might have different internet backbones, different operating systems, and different browsers and browser versions. Catchpoint Global Monitoring Network is a comprehensive 3-minute video that explains the importance of monitoring the client experience.","title":"Third-party monitoring"},{"location":"level101/python_web/intro/","text":"Python and The Web Prerequisites Basic understanding of python language. Basic familiarity with flask framework. What to expect from this course This course is divided into two high level parts. In the first part, assuming familiarity with python language\u2019s basic operations and syntax usage, we will dive a little deeper into understanding python as a language. We will compare python with other programming languages that you might already know like Java and C. We will also explore concepts of Python objects and with help of that, explore python features like decorators. In the second part which will revolve around the web, and also assume familiarity with the Flask framework, we will start from the socket module and work with HTTP requests. This will demystify how frameworks like flask work internally. And to introduce SRE flavour to the course, we will design, develop and deploy (in theory) a URL shortening application. We will emphasize parts of the whole process that are more important as an SRE of the said app/service. What is not covered under this course Extensive knowledge of python internals and advanced python. Lab Environment Setup Have latest version of python installed Course Contents The Python Language Some Python Concepts Python Gotchas Python and Web Sockets Flask The URL Shortening App Design Scaling The App Monitoring The App The Python Language Assuming you know a little bit of C/C++ and Java, let's try to discuss the following questions in context of those two languages and python. You might have heard that C/C++ is a compiled language while python is an interpreted language. Generally, with compiled language we first compile the program and then run the executable while in case of python we run the source code directly like python hello_world.py . While Java, being an interpreted language, still has a separate compilation step and then its run. So what's really the difference? Compiled vs. Interpreted This might sound a little weird to you: python, in a way is a compiled language! Python has a compiler built-in! It is obvious in the case of java since we compile it using a separate command ie: javac helloWorld.java and it will produce a .class file which we know as a bytecode . Well, python is very similar to that. One difference here is that there is no separate compile command/binary needed to run a python program. What is the difference then, between java and python? Well, Java's compiler is more strict and sophisticated. As you might know Java is a statically typed language. So the compiler is written in a way that it can verify types related errors during compile time. While python being a dynamic language, types are not known until a program is run. So in a way, python compiler is dumb (or, less strict). But there indeed is a compile step involved when a python program is run. You might have seen python bytecode files with .pyc extension. Here is how you can see bytecode for a given python program. # Create a Hello World $ echo \"print('hello world')\" > hello_world.py # Making sure it runs $ python3 hello_world.py hello world # The bytecode of the given program $ python -m dis hello_world.py 1 0 LOAD_NAME 0 (print) 2 LOAD_CONST 0 ('hello world') 4 CALL_FUNCTION 1 6 POP_TOP 8 LOAD_CONST 1 (None) 10 RETURN_VALUE Read more about dis module here Now coming to C/C++, there of course is a compiler. But the output is different than what java/python compiler would produce. Compiling a C program would produce what we also know as machine code . As opposed to bytecode. Running The Programs We know compilation is involved in all 3 languages we are discussing. Just that the compilers are different in nature and they output different types of content. In case of C/C++, the output is machine code which can be directly read by your operating system. When you execute that program, your OS will know how exactly to run it. But this is not the case with bytecode. Those bytecodes are language specific. Python has its own set of bytecode defined (more in dis module) and so does java. So naturally, your operating system will not know how to run it. To run this bytecode, we have something called Virtual Machines. Ie: The JVM or the Python VM (CPython, Jython). These so called Virtual Machines are the programs which can read the bytecode and run it on a given operating system. Python has multiple VMs available. Cpython is a python VM implemented in C language, similarly Jython is a Java implementation of python VM. At the end of the day, what they should be capable of is to understand python language syntax, be able to compile it to bytecode and be able to run that bytecode. You can implement a python VM in any language! (And people do so, just because it can be done) The Operating System +------------------------------------+ | | | | | | hello_world.py Python bytecode | Python VM Process | | | +----------------+ +----------------+ | +----------------+ | |print(... | COMPILE |LOAD_CONST... | | |Reads bytecode | | | +--------------->+ +------------------->+line by line | | | | | | | |and executes. | | | | | | | | | | +----------------+ +----------------+ | +----------------+ | | | | | | | hello_world.c OS Specific machinecode | A New Process | | | +----------------+ +----------------+ | +----------------+ | |void main() { | COMPILE | binary contents| | | binary contents| | | +--------------->+ +------------------->+ | | | | | | | | | | | | | | | | | | +----------------+ +----------------+ | +----------------+ | | (binary contents | | runs as is) | | | | | +------------------------------------+ Two things to note for above diagram: Generally, when we run a python program, a python VM process is started which reads the python source code, compiles it to byte code and run it in a single step. Compiling is not a separate step. Shown only for illustration purpose. Binaries generated for C like languages are not exactly run as is. Since there are multiple types of binaries (eg: ELF), there are more complicated steps involved in order to run a binary but we will not go into that since all that is done at OS level.","title":"Introduction"},{"location":"level101/python_web/intro/#python-and-the-web","text":"","title":"Python and The Web"},{"location":"level101/python_web/intro/#prerequisites","text":"Basic understanding of python language. Basic familiarity with flask framework.","title":"Prerequisites"},{"location":"level101/python_web/intro/#what-to-expect-from-this-course","text":"This course is divided into two high level parts. In the first part, assuming familiarity with python language\u2019s basic operations and syntax usage, we will dive a little deeper into understanding python as a language. We will compare python with other programming languages that you might already know like Java and C. We will also explore concepts of Python objects and with help of that, explore python features like decorators. In the second part which will revolve around the web, and also assume familiarity with the Flask framework, we will start from the socket module and work with HTTP requests. This will demystify how frameworks like flask work internally. And to introduce SRE flavour to the course, we will design, develop and deploy (in theory) a URL shortening application. We will emphasize parts of the whole process that are more important as an SRE of the said app/service.","title":"What to expect from this course"},{"location":"level101/python_web/intro/#what-is-not-covered-under-this-course","text":"Extensive knowledge of python internals and advanced python.","title":"What is not covered under this course"},{"location":"level101/python_web/intro/#lab-environment-setup","text":"Have latest version of python installed","title":"Lab Environment Setup"},{"location":"level101/python_web/intro/#course-contents","text":"The Python Language Some Python Concepts Python Gotchas Python and Web Sockets Flask The URL Shortening App Design Scaling The App Monitoring The App","title":"Course Contents"},{"location":"level101/python_web/intro/#the-python-language","text":"Assuming you know a little bit of C/C++ and Java, let's try to discuss the following questions in context of those two languages and python. You might have heard that C/C++ is a compiled language while python is an interpreted language. Generally, with compiled language we first compile the program and then run the executable while in case of python we run the source code directly like python hello_world.py . While Java, being an interpreted language, still has a separate compilation step and then its run. So what's really the difference?","title":"The Python Language"},{"location":"level101/python_web/intro/#compiled-vs-interpreted","text":"This might sound a little weird to you: python, in a way is a compiled language! Python has a compiler built-in! It is obvious in the case of java since we compile it using a separate command ie: javac helloWorld.java and it will produce a .class file which we know as a bytecode . Well, python is very similar to that. One difference here is that there is no separate compile command/binary needed to run a python program. What is the difference then, between java and python? Well, Java's compiler is more strict and sophisticated. As you might know Java is a statically typed language. So the compiler is written in a way that it can verify types related errors during compile time. While python being a dynamic language, types are not known until a program is run. So in a way, python compiler is dumb (or, less strict). But there indeed is a compile step involved when a python program is run. You might have seen python bytecode files with .pyc extension. Here is how you can see bytecode for a given python program. # Create a Hello World $ echo \"print('hello world')\" > hello_world.py # Making sure it runs $ python3 hello_world.py hello world # The bytecode of the given program $ python -m dis hello_world.py 1 0 LOAD_NAME 0 (print) 2 LOAD_CONST 0 ('hello world') 4 CALL_FUNCTION 1 6 POP_TOP 8 LOAD_CONST 1 (None) 10 RETURN_VALUE Read more about dis module here Now coming to C/C++, there of course is a compiler. But the output is different than what java/python compiler would produce. Compiling a C program would produce what we also know as machine code . As opposed to bytecode.","title":"Compiled vs. Interpreted"},{"location":"level101/python_web/intro/#running-the-programs","text":"We know compilation is involved in all 3 languages we are discussing. Just that the compilers are different in nature and they output different types of content. In case of C/C++, the output is machine code which can be directly read by your operating system. When you execute that program, your OS will know how exactly to run it. But this is not the case with bytecode. Those bytecodes are language specific. Python has its own set of bytecode defined (more in dis module) and so does java. So naturally, your operating system will not know how to run it. To run this bytecode, we have something called Virtual Machines. Ie: The JVM or the Python VM (CPython, Jython). These so called Virtual Machines are the programs which can read the bytecode and run it on a given operating system. Python has multiple VMs available. Cpython is a python VM implemented in C language, similarly Jython is a Java implementation of python VM. At the end of the day, what they should be capable of is to understand python language syntax, be able to compile it to bytecode and be able to run that bytecode. You can implement a python VM in any language! (And people do so, just because it can be done) The Operating System +------------------------------------+ | | | | | | hello_world.py Python bytecode | Python VM Process | | | +----------------+ +----------------+ | +----------------+ | |print(... | COMPILE |LOAD_CONST... | | |Reads bytecode | | | +--------------->+ +------------------->+line by line | | | | | | | |and executes. | | | | | | | | | | +----------------+ +----------------+ | +----------------+ | | | | | | | hello_world.c OS Specific machinecode | A New Process | | | +----------------+ +----------------+ | +----------------+ | |void main() { | COMPILE | binary contents| | | binary contents| | | +--------------->+ +------------------->+ | | | | | | | | | | | | | | | | | | +----------------+ +----------------+ | +----------------+ | | (binary contents | | runs as is) | | | | | +------------------------------------+ Two things to note for above diagram: Generally, when we run a python program, a python VM process is started which reads the python source code, compiles it to byte code and run it in a single step. Compiling is not a separate step. Shown only for illustration purpose. Binaries generated for C like languages are not exactly run as is. Since there are multiple types of binaries (eg: ELF), there are more complicated steps involved in order to run a binary but we will not go into that since all that is done at OS level.","title":"Running The Programs"},{"location":"level101/python_web/python-concepts/","text":"Some Python Concepts Though you are expected to know python and its syntax at basic level, let us discuss some fundamental concepts that will help you understand the python language better. Everything in Python is an object. That includes the functions, lists, dicts, classes, modules, a running function (instance of function definition), everything. In the CPython, it would mean there is an underlying struct variable for each object. In python's current execution context, all the variables are stored in a dict. It'd be a string to object mapping. If you have a function and a float variable defined in the current context, here is how it is handled internally. >>> float_number=42.0 >>> def foo_func(): ... pass ... # NOTICE HOW VARIABLE NAMES ARE STRINGS, stored in a dict >>> locals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'float_number': 42.0, 'foo_func': } Python Functions Since functions too are objects, we can see what all attributes a function contains as following >>> def hello(name): ... print(f\"Hello, {name}!\") ... >>> dir(hello) ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'] While there are a lot of them, let's look at some interesting ones globals This attribute, as the name suggests, has references of global variables. If you ever need to know what all global variables are in the scope of this function, this will tell you. See how the function start seeing the new variable in globals >>> hello.__globals__ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'hello': } # adding new global variable >>> GLOBAL=\"g_val\" >>> hello.__globals__ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'hello': , 'GLOBAL': 'g_val'} code This is an interesting one! As everything in python is an object, this includes the bytecode too. The compiled python bytecode is a python code object. Which is accessible via __code__ attribute here. A function has an associated code object which carries some interesting information. # the file in which function is defined # stdin here since this is run in an interpreter >>> hello.__code__.co_filename '' # number of arguments the function takes >>> hello.__code__.co_argcount 1 # local variable names >>> hello.__code__.co_varnames ('name',) # the function code's compiled bytecode >>> hello.__code__.co_code b't\\x00d\\x01|\\x00\\x9b\\x00d\\x02\\x9d\\x03\\x83\\x01\\x01\\x00d\\x00S\\x00' There are more code attributes which you can enlist by >>> dir(hello.__code__) Decorators Related to functions, python has another feature called decorators. Let's see how that works, keeping everything is an object in mind. Here is a sample decorator: >>> def deco(func): ... def inner(): ... print(\"before\") ... func() ... print(\"after\") ... return inner ... >>> @deco ... def hello_world(): ... print(\"hello world\") ... >>> >>> hello_world() before hello world after Here @deco syntax is used to decorate the hello_world function. It is essentially same as doing >>> def hello_world(): ... print(\"hello world\") ... >>> hello_world = deco(hello_world) What goes inside the deco function might seem complex. Let's try to uncover it. Function hello_world is created It is passed to deco function deco create a new function This new function is calls hello_world function And does a couple other things deco returns the newly created function hello_world is replaced with above function Let's visualize it for better understanding BEFORE function_object (ID: 100) \"hello_world\" +--------------------+ + |print(\"hello_world\")| | | | +--------------> | | | | +--------------------+ WHAT DECORATOR DOES creates a new function (ID: 101) +---------------------------------+ |input arg: function with id: 100 | | | |print(\"before\") | |call function object with id 100 | |print(\"after\") | | | +---------------------------------+ ^ | AFTER | | | \"hello_world\" +-------------+ Note how the hello_world name points to a new function object but that new function object knows the reference (ID) of the original function. Some Gotchas While it is very quick to build prototypes in python and there are tons of libraries available, as the codebase complexity increases, type errors become more common and will get hard to deal with. (There are solutions to that problem like type annotations in python. Checkout mypy .) Because python is dynamically typed language, that means all types are determined at runtime. And that makes python run very slow compared to other statically typed languages. Python has something called GIL (global interpreter lock) which is a limiting factor for utilizing multiple CPU cores for parallel computation. Some weird things that python does: https://github.com/satwikkansal/wtfpython","title":"Some Python Concepts"},{"location":"level101/python_web/python-concepts/#some-python-concepts","text":"Though you are expected to know python and its syntax at basic level, let us discuss some fundamental concepts that will help you understand the python language better. Everything in Python is an object. That includes the functions, lists, dicts, classes, modules, a running function (instance of function definition), everything. In the CPython, it would mean there is an underlying struct variable for each object. In python's current execution context, all the variables are stored in a dict. It'd be a string to object mapping. If you have a function and a float variable defined in the current context, here is how it is handled internally. >>> float_number=42.0 >>> def foo_func(): ... pass ... # NOTICE HOW VARIABLE NAMES ARE STRINGS, stored in a dict >>> locals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'float_number': 42.0, 'foo_func': }","title":"Some Python Concepts"},{"location":"level101/python_web/python-concepts/#python-functions","text":"Since functions too are objects, we can see what all attributes a function contains as following >>> def hello(name): ... print(f\"Hello, {name}!\") ... >>> dir(hello) ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'] While there are a lot of them, let's look at some interesting ones","title":"Python Functions"},{"location":"level101/python_web/python-concepts/#globals","text":"This attribute, as the name suggests, has references of global variables. If you ever need to know what all global variables are in the scope of this function, this will tell you. See how the function start seeing the new variable in globals >>> hello.__globals__ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'hello': } # adding new global variable >>> GLOBAL=\"g_val\" >>> hello.__globals__ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'hello': , 'GLOBAL': 'g_val'}","title":"globals"},{"location":"level101/python_web/python-concepts/#code","text":"This is an interesting one! As everything in python is an object, this includes the bytecode too. The compiled python bytecode is a python code object. Which is accessible via __code__ attribute here. A function has an associated code object which carries some interesting information. # the file in which function is defined # stdin here since this is run in an interpreter >>> hello.__code__.co_filename '' # number of arguments the function takes >>> hello.__code__.co_argcount 1 # local variable names >>> hello.__code__.co_varnames ('name',) # the function code's compiled bytecode >>> hello.__code__.co_code b't\\x00d\\x01|\\x00\\x9b\\x00d\\x02\\x9d\\x03\\x83\\x01\\x01\\x00d\\x00S\\x00' There are more code attributes which you can enlist by >>> dir(hello.__code__)","title":"code"},{"location":"level101/python_web/python-concepts/#decorators","text":"Related to functions, python has another feature called decorators. Let's see how that works, keeping everything is an object in mind. Here is a sample decorator: >>> def deco(func): ... def inner(): ... print(\"before\") ... func() ... print(\"after\") ... return inner ... >>> @deco ... def hello_world(): ... print(\"hello world\") ... >>> >>> hello_world() before hello world after Here @deco syntax is used to decorate the hello_world function. It is essentially same as doing >>> def hello_world(): ... print(\"hello world\") ... >>> hello_world = deco(hello_world) What goes inside the deco function might seem complex. Let's try to uncover it. Function hello_world is created It is passed to deco function deco create a new function This new function is calls hello_world function And does a couple other things deco returns the newly created function hello_world is replaced with above function Let's visualize it for better understanding BEFORE function_object (ID: 100) \"hello_world\" +--------------------+ + |print(\"hello_world\")| | | | +--------------> | | | | +--------------------+ WHAT DECORATOR DOES creates a new function (ID: 101) +---------------------------------+ |input arg: function with id: 100 | | | |print(\"before\") | |call function object with id 100 | |print(\"after\") | | | +---------------------------------+ ^ | AFTER | | | \"hello_world\" +-------------+ Note how the hello_world name points to a new function object but that new function object knows the reference (ID) of the original function.","title":"Decorators"},{"location":"level101/python_web/python-concepts/#some-gotchas","text":"While it is very quick to build prototypes in python and there are tons of libraries available, as the codebase complexity increases, type errors become more common and will get hard to deal with. (There are solutions to that problem like type annotations in python. Checkout mypy .) Because python is dynamically typed language, that means all types are determined at runtime. And that makes python run very slow compared to other statically typed languages. Python has something called GIL (global interpreter lock) which is a limiting factor for utilizing multiple CPU cores for parallel computation. Some weird things that python does: https://github.com/satwikkansal/wtfpython","title":"Some Gotchas"},{"location":"level101/python_web/python-web-flask/","text":"Python, Web and Flask Back in the old days, websites were simple. They were simple static html contents. A webserver would be listening on a defined port and according to the HTTP request received, it would read files from disk and return them in response. But since then, complexity has evolved and websites are now dynamic. Depending on the request, multiple operations need to be performed like reading from database or calling other API and finally returning some response (HTML data, JSON content etc.) Since serving web requests is no longer a simple task like reading files from disk and return contents, we need to process each http request, perform some operations programmatically and construct a response. Sockets Though we have frameworks like flask, HTTP is still a protocol that works over TCP protocol. So let us setup a TCP server and send an HTTP request and inspect the request's payload. Note that this is not a tutorial on socket programming but what we are doing here is inspecting HTTP protocol at its ground level and look at what its contents look like. (Ref: Socket Programming in Python (Guide) on RealPython ) import socket HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() conn, addr = s.accept() with conn: print('Connected by', addr) while True: data = conn.recv(1024) if not data: break print(data) Then we open localhost:65432 in our web browser and following would be the output: Connected by ('127.0.0.1', 54719) b'GET / HTTP/1.1\\r\\nHost: localhost:65432\\r\\nConnection: keep-alive\\r\\nDNT: 1\\r\\nUpgrade-Insecure-Requests: 1\\r\\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36 Edg/85.0.564.44\\r\\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\\r\\nSec-Fetch-Site: none\\r\\nSec-Fetch-Mode: navigate\\r\\nSec-Fetch-User: ?1\\r\\nSec-Fetch-Dest: document\\r\\nAccept-Encoding: gzip, deflate, br\\r\\nAccept-Language: en-US,en;q=0.9\\r\\n\\r\\n' Examine closely and the content will look like the HTTP protocol's format. ie: HTTP_METHOD URI_PATH HTTP_VERSION HEADERS_SEPARATED_BY_SEPARATOR So though it's a blob of bytes, knowing http protocol specification , you can parse that string (ie: split by \\r\\n ) and get meaningful information out of it. Flask Flask, and other such frameworks does pretty much what we just discussed in the last section (with added more sophistication). They listen on a port on a TCP socket, receive an HTTP request, parse the data according to protocol format and make it available to you in a convenient manner. ie: you can access headers in flask by request.headers which is made available to you by splitting above payload by /r/n , as defined in http protocol. Another example: we register routes in flask by @app.route(\"/hello\") . What flask will do is maintain a registry internally which will map /hello with the function you decorated with. Now whenever a request comes with the /hello route (second component in the first line, split by space), flask calls the registered function and returns whatever the function returned. Same with all other web frameworks in other languages too. They all work on similar principles. What they basically do is understand the HTTP protocol, parses the HTTP request data and gives us programmers a nice interface to work with HTTP requests. Not so much of magic, innit?","title":"Python, Web and Flask"},{"location":"level101/python_web/python-web-flask/#python-web-and-flask","text":"Back in the old days, websites were simple. They were simple static html contents. A webserver would be listening on a defined port and according to the HTTP request received, it would read files from disk and return them in response. But since then, complexity has evolved and websites are now dynamic. Depending on the request, multiple operations need to be performed like reading from database or calling other API and finally returning some response (HTML data, JSON content etc.) Since serving web requests is no longer a simple task like reading files from disk and return contents, we need to process each http request, perform some operations programmatically and construct a response.","title":"Python, Web and Flask"},{"location":"level101/python_web/python-web-flask/#sockets","text":"Though we have frameworks like flask, HTTP is still a protocol that works over TCP protocol. So let us setup a TCP server and send an HTTP request and inspect the request's payload. Note that this is not a tutorial on socket programming but what we are doing here is inspecting HTTP protocol at its ground level and look at what its contents look like. (Ref: Socket Programming in Python (Guide) on RealPython ) import socket HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() conn, addr = s.accept() with conn: print('Connected by', addr) while True: data = conn.recv(1024) if not data: break print(data) Then we open localhost:65432 in our web browser and following would be the output: Connected by ('127.0.0.1', 54719) b'GET / HTTP/1.1\\r\\nHost: localhost:65432\\r\\nConnection: keep-alive\\r\\nDNT: 1\\r\\nUpgrade-Insecure-Requests: 1\\r\\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36 Edg/85.0.564.44\\r\\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\\r\\nSec-Fetch-Site: none\\r\\nSec-Fetch-Mode: navigate\\r\\nSec-Fetch-User: ?1\\r\\nSec-Fetch-Dest: document\\r\\nAccept-Encoding: gzip, deflate, br\\r\\nAccept-Language: en-US,en;q=0.9\\r\\n\\r\\n' Examine closely and the content will look like the HTTP protocol's format. ie: HTTP_METHOD URI_PATH HTTP_VERSION HEADERS_SEPARATED_BY_SEPARATOR So though it's a blob of bytes, knowing http protocol specification , you can parse that string (ie: split by \\r\\n ) and get meaningful information out of it.","title":"Sockets"},{"location":"level101/python_web/python-web-flask/#flask","text":"Flask, and other such frameworks does pretty much what we just discussed in the last section (with added more sophistication). They listen on a port on a TCP socket, receive an HTTP request, parse the data according to protocol format and make it available to you in a convenient manner. ie: you can access headers in flask by request.headers which is made available to you by splitting above payload by /r/n , as defined in http protocol. Another example: we register routes in flask by @app.route(\"/hello\") . What flask will do is maintain a registry internally which will map /hello with the function you decorated with. Now whenever a request comes with the /hello route (second component in the first line, split by space), flask calls the registered function and returns whatever the function returned. Same with all other web frameworks in other languages too. They all work on similar principles. What they basically do is understand the HTTP protocol, parses the HTTP request data and gives us programmers a nice interface to work with HTTP requests. Not so much of magic, innit?","title":"Flask"},{"location":"level101/python_web/sre-conclusion/","text":"Conclusion Scaling The App The design and development is just a part of the journey. We will need to setup continuous integration and continuous delivery pipelines sooner or later. And we have to deploy this app somewhere. Initially we can start with deploying this app on one virtual machine on any cloud provider. But this is a Single point of failure which is something we never allow as an SRE (or even as an engineer). So an improvement here can be having multiple instances of applications deployed behind a load balancer. This certainly prevents problems of one machine going down. Scaling here would mean adding more instances behind the load balancer. But this is scalable upto only a certain point. After that, other bottlenecks in the system will start appearing. ie: DB will become the bottleneck, or perhaps the load balancer itself. How do you know what is the bottleneck? You need to have observability into each aspects of the application architecture. Only after you have metrics, you will be able to know what is going wrong where. What gets measured, gets fixed! Get deeper insights into scaling from School Of SRE's Scalability module and post going through it, apply your learnings and takeaways to this app. Think how will we make this app geographically distributed and highly available and scalable. Monitoring Strategy Once we have our application deployed. It will be working ok. But not forever. Reliability is in the title of our job and we make systems reliable by making the design in a certain way. But things still will go down. Machines will fail. Disks will behave weirdly. Buggy code will get pushed to production. And all these possible scenarios will make the system less reliable. So what do we do? We monitor! We keep an eye on the system's health and if anything is not going as expected, we want ourselves to get alerted. Now let's think in terms of the given url shortening app. We need to monitor it. And we would want to get notified in case something goes wrong. But we first need to decide what is that something that we want to keep an eye on. Since it's a web app serving HTTP requests, we want to keep an eye on HTTP Status codes and latencies Request volume again is a good candidate, if the app is receiving an unusual amount of traffic, something might be off. We also want to keep an eye on the database so depending on the database solution chosen. Query times, volumes, disk usage etc. Finally, there also needs to be some external monitoring which runs periodic tests from devices outside of your data centers. This emulates customers and ensures that from customer point of view, the system is working as expected. Applications in SRE role In the world of SRE, python is a widely used language. For small scripts and tooling developed for various purposes. Since tooling developed by SRE works with critical pieces of infrastructure and has great power (to bring things down), it is important to know what you are doing while using a programming language and its features. Also it is equally important to know the language and its characteristics while debugging the issues. As an SRE having a deeper understanding of python language, it has helped me a lot to debug very sneaky bugs and be generally more aware and informed while making certain design decisions. While developing tools may or may not be part of SRE job, supporting tools or services is more likely to be a daily duty. Building an application or tool is just a small part of productionization. While there is certainly that goes in the design of the application itself to make it more robust, as an SRE you are responsible for its reliability and stability once it is deployed and running. And to ensure that, you\u2019d need to understand the application first and then come up with a strategy to monitor it properly and be prepared for various failure scenarios. Optional Exercises Make a decorator that will cache function return values depending on input parameters. Host the URL shortening app on any cloud provider. Setup monitoring using many of the tools available like catchpoint, datadog etc. Create a minimal flask-like framework on top of TCP sockets. Conclusion This module, in the first part, aims to make you more aware of the things that will happen when you choose python as your programming language and what happens when you run a python program. With the knowledge of how python handles things internally as objects, lot of seemingly magic things in python will start to make more sense. The second part will first explain how a framework like flask works using the existing knowledge of protocols like TCP and HTTP. It then touches the whole lifecycle of an application development lifecycle including the SRE parts of it. While the design and areas in architecture considered will not be exhaustive, it will give a good overview of things that are also important being an SRE and why they are important.","title":"Conclusion"},{"location":"level101/python_web/sre-conclusion/#conclusion","text":"","title":"Conclusion"},{"location":"level101/python_web/sre-conclusion/#scaling-the-app","text":"The design and development is just a part of the journey. We will need to setup continuous integration and continuous delivery pipelines sooner or later. And we have to deploy this app somewhere. Initially we can start with deploying this app on one virtual machine on any cloud provider. But this is a Single point of failure which is something we never allow as an SRE (or even as an engineer). So an improvement here can be having multiple instances of applications deployed behind a load balancer. This certainly prevents problems of one machine going down. Scaling here would mean adding more instances behind the load balancer. But this is scalable upto only a certain point. After that, other bottlenecks in the system will start appearing. ie: DB will become the bottleneck, or perhaps the load balancer itself. How do you know what is the bottleneck? You need to have observability into each aspects of the application architecture. Only after you have metrics, you will be able to know what is going wrong where. What gets measured, gets fixed! Get deeper insights into scaling from School Of SRE's Scalability module and post going through it, apply your learnings and takeaways to this app. Think how will we make this app geographically distributed and highly available and scalable.","title":"Scaling The App"},{"location":"level101/python_web/sre-conclusion/#monitoring-strategy","text":"Once we have our application deployed. It will be working ok. But not forever. Reliability is in the title of our job and we make systems reliable by making the design in a certain way. But things still will go down. Machines will fail. Disks will behave weirdly. Buggy code will get pushed to production. And all these possible scenarios will make the system less reliable. So what do we do? We monitor! We keep an eye on the system's health and if anything is not going as expected, we want ourselves to get alerted. Now let's think in terms of the given url shortening app. We need to monitor it. And we would want to get notified in case something goes wrong. But we first need to decide what is that something that we want to keep an eye on. Since it's a web app serving HTTP requests, we want to keep an eye on HTTP Status codes and latencies Request volume again is a good candidate, if the app is receiving an unusual amount of traffic, something might be off. We also want to keep an eye on the database so depending on the database solution chosen. Query times, volumes, disk usage etc. Finally, there also needs to be some external monitoring which runs periodic tests from devices outside of your data centers. This emulates customers and ensures that from customer point of view, the system is working as expected.","title":"Monitoring Strategy"},{"location":"level101/python_web/sre-conclusion/#applications-in-sre-role","text":"In the world of SRE, python is a widely used language. For small scripts and tooling developed for various purposes. Since tooling developed by SRE works with critical pieces of infrastructure and has great power (to bring things down), it is important to know what you are doing while using a programming language and its features. Also it is equally important to know the language and its characteristics while debugging the issues. As an SRE having a deeper understanding of python language, it has helped me a lot to debug very sneaky bugs and be generally more aware and informed while making certain design decisions. While developing tools may or may not be part of SRE job, supporting tools or services is more likely to be a daily duty. Building an application or tool is just a small part of productionization. While there is certainly that goes in the design of the application itself to make it more robust, as an SRE you are responsible for its reliability and stability once it is deployed and running. And to ensure that, you\u2019d need to understand the application first and then come up with a strategy to monitor it properly and be prepared for various failure scenarios.","title":"Applications in SRE role"},{"location":"level101/python_web/sre-conclusion/#optional-exercises","text":"Make a decorator that will cache function return values depending on input parameters. Host the URL shortening app on any cloud provider. Setup monitoring using many of the tools available like catchpoint, datadog etc. Create a minimal flask-like framework on top of TCP sockets.","title":"Optional Exercises"},{"location":"level101/python_web/sre-conclusion/#conclusion_1","text":"This module, in the first part, aims to make you more aware of the things that will happen when you choose python as your programming language and what happens when you run a python program. With the knowledge of how python handles things internally as objects, lot of seemingly magic things in python will start to make more sense. The second part will first explain how a framework like flask works using the existing knowledge of protocols like TCP and HTTP. It then touches the whole lifecycle of an application development lifecycle including the SRE parts of it. While the design and areas in architecture considered will not be exhaustive, it will give a good overview of things that are also important being an SRE and why they are important.","title":"Conclusion"},{"location":"level101/python_web/url-shorten-app/","text":"The URL Shortening App Let's build a very simple URL shortening app using flask and try to incorporate all aspects of the development process including the reliability aspects. We will not be building the UI and we will come up with a minimal set of API that will be enough for the app to function well. Design We don't jump directly to coding. First thing we do is gather requirements. Come up with an approach. Have the approach/design reviewed by peers. Evolve, iterate, document the decisions and tradeoffs. And then finally implement. While we will not do the full blown design document here, we will raise certain questions here that are important to the design. 1. High Level Operations and API Endpoints Since it's a URL shortening app, we will need an API for generating the shorten link given an original link. And an API/Endpoint which will accept the shorten link and redirect to original URL. We are not including the user aspect of the app to keep things minimal. These two API should make app functional and usable by anyone. 2. How to shorten? Given a url, we will need to generate a shortened version of it. One approach could be using random characters for each link. Another thing that can be done is to use some sort of hashing algorithm. The benefit here is we will reuse the same hash for the same link. ie: if lot of people are shortening https://www.linkedin.com they all will have the same value, compared to multiple entries in DB if chosen random characters. What about hash collisions? Even in random characters approach, though there is a less probability, hash collisions can happen. And we need to be mindful of them. In that case we might want to prepend/append the string with some random value to avoid conflict. Also, choice of hash algorithm matters. We will need to analyze algorithms. Their CPU requirements and their characteristics. Choose one that suits the most. 3. Is URL Valid? Given a URL to shorten, how do we verify if the URL is valid? Do we even verify or validate? One basic check that can be done is see if the URL matches a regex of a URL. To go even further we can try opening/visiting the URL. But there are certain gotchas here. We need to define success criteria. ie: HTTP 200 means it is valid. What is the URL is in private network? What if URL is temporarily down? 4. Storage Finally, storage. Where will we store the data that we will generate over time? There are multiple database solutions available and we will need to choose the one that suits this app the most. Relational database like MySQL would be a fair choice but be sure to checkout School of SRE's SQL database section and NoSQL databases section for deeper insights into making a more informed decision. 5. Other We are not accounting for users into our app and other possible features like rate limiting, customized links etc but it will eventually come up with time. Depending on the requirements, they too might need to get incorporated. The minimal working code is given below for reference but I'd encourage you to come up with your own. from flask import Flask, redirect, request from hashlib import md5 app = Flask(\"url_shortener\") mapping = {} @app.route(\"/shorten\", methods=[\"POST\"]) def shorten(): global mapping payload = request.json if \"url\" not in payload: return \"Missing URL Parameter\", 400 # TODO: check if URL is valid hash_ = md5() hash_.update(payload[\"url\"].encode()) digest = hash_.hexdigest()[:5] # limiting to 5 chars. Less the limit more the chances of collission if digest not in mapping: mapping[digest] = payload[\"url\"] return f\"Shortened: r/{digest}\\n\" else: # TODO: check for hash collission return f\"Already exists: r/{digest}\\n\" @app.route(\"/r/\") def redirect_(hash_): if hash_ not in mapping: return \"URL Not Found\", 404 return redirect(mapping[hash_]) if __name__ == \"__main__\": app.run(debug=True) \"\"\" OUTPUT: ===> SHORTENING $ curl localhost:5000/shorten -H \"content-type: application/json\" --data '{\"url\":\"https://linkedin.com\"}' Shortened: r/a62a4 ===> REDIRECTING, notice the response code 302 and the location header $ curl localhost:5000/r/a62a4 -v * Uses proxy env variable NO_PROXY == '127.0.0.1' * Trying ::1... * TCP_NODELAY set * Connection failed * connect to ::1 port 5000 failed: Connection refused * Trying 127.0.0.1... * TCP_NODELAY set * Connected to localhost (127.0.0.1) port 5000 (#0) > GET /r/a62a4 HTTP/1.1 > Host: localhost:5000 > User-Agent: curl/7.64.1 > Accept: */* > * HTTP 1.0, assume close after body < HTTP/1.0 302 FOUND < Content-Type: text/html; charset=utf-8 < Content-Length: 247 < Location: https://linkedin.com < Server: Werkzeug/0.15.4 Python/3.7.7 < Date: Tue, 27 Oct 2020 09:37:12 GMT < Redirecting...

    Redirecting...

    * Closing connection 0

    You should be redirected automatically to target URL: https://linkedin.com. If not click the link. \"\"\"","title":"The URL Shortening App"},{"location":"level101/python_web/url-shorten-app/#the-url-shortening-app","text":"Let's build a very simple URL shortening app using flask and try to incorporate all aspects of the development process including the reliability aspects. We will not be building the UI and we will come up with a minimal set of API that will be enough for the app to function well.","title":"The URL Shortening App"},{"location":"level101/python_web/url-shorten-app/#design","text":"We don't jump directly to coding. First thing we do is gather requirements. Come up with an approach. Have the approach/design reviewed by peers. Evolve, iterate, document the decisions and tradeoffs. And then finally implement. While we will not do the full blown design document here, we will raise certain questions here that are important to the design.","title":"Design"},{"location":"level101/python_web/url-shorten-app/#1-high-level-operations-and-api-endpoints","text":"Since it's a URL shortening app, we will need an API for generating the shorten link given an original link. And an API/Endpoint which will accept the shorten link and redirect to original URL. We are not including the user aspect of the app to keep things minimal. These two API should make app functional and usable by anyone.","title":"1. High Level Operations and API Endpoints"},{"location":"level101/python_web/url-shorten-app/#2-how-to-shorten","text":"Given a url, we will need to generate a shortened version of it. One approach could be using random characters for each link. Another thing that can be done is to use some sort of hashing algorithm. The benefit here is we will reuse the same hash for the same link. ie: if lot of people are shortening https://www.linkedin.com they all will have the same value, compared to multiple entries in DB if chosen random characters. What about hash collisions? Even in random characters approach, though there is a less probability, hash collisions can happen. And we need to be mindful of them. In that case we might want to prepend/append the string with some random value to avoid conflict. Also, choice of hash algorithm matters. We will need to analyze algorithms. Their CPU requirements and their characteristics. Choose one that suits the most.","title":"2. How to shorten?"},{"location":"level101/python_web/url-shorten-app/#3-is-url-valid","text":"Given a URL to shorten, how do we verify if the URL is valid? Do we even verify or validate? One basic check that can be done is see if the URL matches a regex of a URL. To go even further we can try opening/visiting the URL. But there are certain gotchas here. We need to define success criteria. ie: HTTP 200 means it is valid. What is the URL is in private network? What if URL is temporarily down?","title":"3. Is URL Valid?"},{"location":"level101/python_web/url-shorten-app/#4-storage","text":"Finally, storage. Where will we store the data that we will generate over time? There are multiple database solutions available and we will need to choose the one that suits this app the most. Relational database like MySQL would be a fair choice but be sure to checkout School of SRE's SQL database section and NoSQL databases section for deeper insights into making a more informed decision.","title":"4. Storage"},{"location":"level101/python_web/url-shorten-app/#5-other","text":"We are not accounting for users into our app and other possible features like rate limiting, customized links etc but it will eventually come up with time. Depending on the requirements, they too might need to get incorporated. The minimal working code is given below for reference but I'd encourage you to come up with your own. from flask import Flask, redirect, request from hashlib import md5 app = Flask(\"url_shortener\") mapping = {} @app.route(\"/shorten\", methods=[\"POST\"]) def shorten(): global mapping payload = request.json if \"url\" not in payload: return \"Missing URL Parameter\", 400 # TODO: check if URL is valid hash_ = md5() hash_.update(payload[\"url\"].encode()) digest = hash_.hexdigest()[:5] # limiting to 5 chars. Less the limit more the chances of collission if digest not in mapping: mapping[digest] = payload[\"url\"] return f\"Shortened: r/{digest}\\n\" else: # TODO: check for hash collission return f\"Already exists: r/{digest}\\n\" @app.route(\"/r/\") def redirect_(hash_): if hash_ not in mapping: return \"URL Not Found\", 404 return redirect(mapping[hash_]) if __name__ == \"__main__\": app.run(debug=True) \"\"\" OUTPUT: ===> SHORTENING $ curl localhost:5000/shorten -H \"content-type: application/json\" --data '{\"url\":\"https://linkedin.com\"}' Shortened: r/a62a4 ===> REDIRECTING, notice the response code 302 and the location header $ curl localhost:5000/r/a62a4 -v * Uses proxy env variable NO_PROXY == '127.0.0.1' * Trying ::1... * TCP_NODELAY set * Connection failed * connect to ::1 port 5000 failed: Connection refused * Trying 127.0.0.1... * TCP_NODELAY set * Connected to localhost (127.0.0.1) port 5000 (#0) > GET /r/a62a4 HTTP/1.1 > Host: localhost:5000 > User-Agent: curl/7.64.1 > Accept: */* > * HTTP 1.0, assume close after body < HTTP/1.0 302 FOUND < Content-Type: text/html; charset=utf-8 < Content-Length: 247 < Location: https://linkedin.com < Server: Werkzeug/0.15.4 Python/3.7.7 < Date: Tue, 27 Oct 2020 09:37:12 GMT < Redirecting...

    Redirecting...

    * Closing connection 0

    You should be redirected automatically to target URL: https://linkedin.com. If not click the link. \"\"\"","title":"5. Other"},{"location":"level101/security/conclusion/","text":"Conclusion Now that you have completed this course on Security you are now aware of the possible security threats to computer systems & networks. Not only that, but you are now better able to protect your systems as well as recommend security measures to others. This course provides fundamental everyday knowledge on security domain which will also help you keep security at the top of your priority. Other Resources Some books that would be a great resource Holistic Info-Sec for Web Developers https://holisticinfosecforwebdevelopers.com/ - Free and downloadable book series with very broad and deep coverage of what Web Developers and DevOps Engineers need to know in order to create robust, reliable, maintainable and secure software, networks and other, that are delivered continuously, on time, with no nasty surprises Docker Security - Quick Reference: For DevOps Engineers https://leanpub.com/dockersecurity-quickreference - A book on understanding the Docker security defaults, how to improve them (theory and practical), along with many tools and techniques. How to Hack Like a Legend https://amzn.to/2uWh1Up - A hacker\u2019s tale breaking into a secretive offshore company, Sparc Flow, 2018 How to Investigate Like a Rockstar https://books2read.com/u/4jDWoZ - Live a real crisis to master the secrets of forensic analysis, Sparc Flow, 2017 Real World Cryptography https://www.manning.com/books/real-world-cryptography - This early-access book teaches you applied cryptographic techniques to understand and apply security at every level of your systems and applications. AWS Security https://www.manning.com/books/aws-security?utm_source=github&utm_medium=organic&utm_campaign=book_shields_aws_1_31_20 - This early-access book covers commong AWS security issues and best practices for access policies, data protection, auditing, continuous monitoring, and incident response. Post Training asks/ Further Reading CTF Events like : https://github.com/apsdehal/awesome-ctf Penetration Testing : https://github.com/enaqx/awesome-pentest Threat Intelligence : https://github.com/hslatman/awesome-threat-intelligence Threat Detection & Hunting : https://github.com/0x4D31/awesome-threat-detection Web Security: https://github.com/qazbnm456/awesome-web-security Building Secure and Reliable Systems : https://landing.google.com/sre/resources/foundationsandprinciples/srs-book/","title":"Conclusion"},{"location":"level101/security/conclusion/#conclusion","text":"Now that you have completed this course on Security you are now aware of the possible security threats to computer systems & networks. Not only that, but you are now better able to protect your systems as well as recommend security measures to others. This course provides fundamental everyday knowledge on security domain which will also help you keep security at the top of your priority.","title":"Conclusion"},{"location":"level101/security/conclusion/#other-resources","text":"Some books that would be a great resource Holistic Info-Sec for Web Developers https://holisticinfosecforwebdevelopers.com/ - Free and downloadable book series with very broad and deep coverage of what Web Developers and DevOps Engineers need to know in order to create robust, reliable, maintainable and secure software, networks and other, that are delivered continuously, on time, with no nasty surprises Docker Security - Quick Reference: For DevOps Engineers https://leanpub.com/dockersecurity-quickreference - A book on understanding the Docker security defaults, how to improve them (theory and practical), along with many tools and techniques. How to Hack Like a Legend https://amzn.to/2uWh1Up - A hacker\u2019s tale breaking into a secretive offshore company, Sparc Flow, 2018 How to Investigate Like a Rockstar https://books2read.com/u/4jDWoZ - Live a real crisis to master the secrets of forensic analysis, Sparc Flow, 2017 Real World Cryptography https://www.manning.com/books/real-world-cryptography - This early-access book teaches you applied cryptographic techniques to understand and apply security at every level of your systems and applications. AWS Security https://www.manning.com/books/aws-security?utm_source=github&utm_medium=organic&utm_campaign=book_shields_aws_1_31_20 - This early-access book covers commong AWS security issues and best practices for access policies, data protection, auditing, continuous monitoring, and incident response.","title":"Other Resources"},{"location":"level101/security/conclusion/#post-training-asks-further-reading","text":"CTF Events like : https://github.com/apsdehal/awesome-ctf Penetration Testing : https://github.com/enaqx/awesome-pentest Threat Intelligence : https://github.com/hslatman/awesome-threat-intelligence Threat Detection & Hunting : https://github.com/0x4D31/awesome-threat-detection Web Security: https://github.com/qazbnm456/awesome-web-security Building Secure and Reliable Systems : https://landing.google.com/sre/resources/foundationsandprinciples/srs-book/","title":"Post Training asks/ Further Reading"},{"location":"level101/security/fundamentals/","text":"Part I: Fundamentals Introduction to Security Overview for SRE If you look closely, both Site Reliability Engineering and Security Engineering are concerned with keeping a system usable. Issues like broken releases, capacity shortages, and misconfigurations can make a system unusable (at least temporarily). Security or privacy incidents that break the trust of users also undermine the usefulness of a system. Consequently, system security should be top of mind for SREs. SREs should be involved in both significant design discussions and actual system changes. They have quite a big role in System design & hence are quite sometimes the first line of defence. SRE\u2019s help in preventing bad design & implementations which can affect the overall security of the infrastructure. Successfully designing, implementing, and maintaining systems requires a commitment to the full system lifecycle . This commitment is possible only when security and reliability are central elements in the architecture of systems. Core Pillars of Information Security : Confidentiality \u2013 only allow access to data for which the user is permitted Integrity \u2013 ensure data is not tampered or altered by unauthorized users Availability \u2013 ensure systems and data are available to authorized users when they need it Thinking like a Security Engineer When starting a new application or re-factoring an existing application, you should consider each functional feature, and consider: Is the process surrounding this feature as safe as possible? In other words, is this a flawed process? If I were evil, how would I abuse this feature? Or more specifically failing to address how a feature can be abused can cause design flaws. Is the feature required to be on by default? If so, are there limits or options that could help reduce the risk from this feature? Security Principles By OWASP (Open Web Application Security Project) Minimize attack surface area : Every feature that is added to an application adds a certain amount of risk to the overall application. The aim of secure development is to reduce the overall risk by reducing the attack surface area. For example, a web application implements online help with a search function. The search function may be vulnerable to SQL injection attacks. If the help feature was limited to authorized users, the attack likelihood is reduced. If the help feature\u2019s search function was gated through centralized data validation routines, the ability to perform SQL injection is dramatically reduced. However, if the help feature was re-written to eliminate the search function (through a better user interface, for example), this almost eliminates the attack surface area, even if the help feature was available to the Internet at large. Establish secure defaults: There are many ways to deliver an \u201cout of the box\u201d experience for users. However, by default, the experience should be secure, and it should be up to the user to reduce their security \u2013 if they are allowed. For example, by default, password ageing and complexity should be enabled. Users might be allowed to turn these two features off to simplify their use of the application and increase their risk. Default Passwords of routers, IoT devices should be changed Principle of Least privilege The principle of least privilege recommends that accounts have the least amount of privilege required to perform their business processes. This encompasses user rights, resource permissions such as CPU limits, memory, network, and file system permissions. For example, if a middleware server only requires access to the network, read access to a database table, and the ability to write to a log, this describes all the permissions that should be granted. Under no circumstances should the middleware be granted administrative privileges. Principle of Defense in depth The principle of defence in depth suggests that where one control would be reasonable, more controls that approach risks in different fashions are better. Controls, when used in depth, can make severe vulnerabilities extraordinarily difficult to exploit and thus unlikely to occur. With secure coding, this may take the form of tier-based validation, centralized auditing controls, and requiring users to be logged on all pages. For example, a flawed administrative interface is unlikely to be vulnerable to an anonymous attack if it correctly gates access to production management networks, checks for administrative user authorization, and logs all access. Fail securely Applications regularly fail to process transactions for many reasons. How they fail can determine if an application is secure or not. ``` is_admin = true; try { code_which_may_faile(); is_admin = is_user_assigned_role(\"Adminstrator\"); } catch (Exception err) { log.error(err.toString()); } ``` - If either codeWhichMayFail() or isUserInRole fails or throws an exception, the user is an admin by default. This is obviously a security risk. Don\u2019t trust services Many organizations utilize the processing capabilities of third-party partners, who more than likely have different security policies and posture than you. It is unlikely that you can influence or control any external third party, whether they are home users or major suppliers or partners. Therefore, the implicit trust of externally run systems is not warranted. All external systems should be treated similarly. For example, a loyalty program provider provides data that is used by Internet Banking, providing the number of reward points and a small list of potential redemption items. However, the data should be checked to ensure that it is safe to display to end-users and that the reward points are a positive number, and not improbably large. Separation of duties The key to fraud control is the separation of duties. For example, someone who requests a computer cannot also sign for it, nor should they directly receive the computer. This prevents the user from requesting many computers and claiming they never arrived. Certain roles have different levels of trust than normal users. In particular, administrators are different from normal users. In general, administrators should not be users of the application. For example, an administrator should be able to turn the system on or off, set password policy but shouldn\u2019t be able to log on to the storefront as a super privileged user, such as being able to \u201cbuy\u201d goods on behalf of other users. Avoid security by obscurity Security through obscurity is a weak security control, and nearly always fails when it is the only control. This is not to say that keeping secrets is a bad idea, it simply means that the security of systems should not be reliant upon keeping details hidden. For example, the security of an application should not rely upon knowledge of the source code being kept secret. The security should rely upon many other factors, including reasonable password policies, defence in depth, business transaction limits, solid network architecture, and fraud, and audit controls. A practical example is Linux. Linux\u2019s source code is widely available, and yet when properly secured, Linux is a secure and robust operating system. Keep security simple Attack surface area and simplicity go hand in hand. Certain software engineering practices prefer overly complex approaches to what would otherwise be a relatively straightforward and simple design. Developers should avoid the use of double negatives and complex architectures when a simpler approach would be faster and simpler. For example, although it might be fashionable to have a slew of singleton entity beans running on a separate middleware server, it is more secure and faster to simply use global variables with an appropriate mutex mechanism to protect against race conditions. Fix security issues correctly Once a security issue has been identified, it is important to develop a test for it and to understand the root cause of the issue. When design patterns are used, the security issue is likely widespread amongst all codebases, so developing the right fix without introducing regressions is essential. For example, a user has found that they can see another user\u2019s balance by adjusting their cookie. The fix seems to be relatively straightforward, but as the cookie handling code is shared among all applications, a change to just one application will trickle through to all other applications. The fix must, therefore, be tested on all affected applications. Reliability & Security Reliability and security are both crucial components of a truly trustworthy system, but building systems that are both reliable and secure is difficult. While the requirements for reliability and security share many common properties, they also require different design considerations. It is easy to miss the subtle interplay between reliability and security that can cause unexpected outcomes Ex: A password management application failure was triggered by a reliability problem i.e poor load-balancing and load-shedding strategies and its recovery were later complicated by multiple measures (HSM mechanism which needs to be plugged into server racks, which works as an authentication & the HSM token supposedly locked inside a case.. & the problem can be further elongated ) designed to increase the security of the system. Authentication vs Authorization Authentication is the act of validating that users are who they claim to be. Passwords are the most common authentication factor\u2014if a user enters the correct password, the system assumes the identity is valid and grants access. Other technologies such as One-Time Pins, authentication apps, and even biometrics can also be used to authenticate identity. In some instances, systems require the successful verification of more than one factor before granting access. This multi-factor authentication (MFA) requirement is often deployed to increase security beyond what passwords alone can provide. Authorization in system security is the process of giving the user permission to access a specific resource or function. This term is often used interchangeably with access control or client privilege. Giving someone permission to download a particular file on a server or providing individual users with administrative access to an application are good examples. In secure environments, authorization must always follow authentication, users should first prove that their identities are genuine before an organization\u2019s administrators grant them access to the requested resources. Common authentication flow (local authentication) The user registers using an identifier like username/email/mobile The application stores user credentials in the database The application sends a verification email/message to validate the registration Post successful registration, the user enters credentials for logging in On successful authentication, the user is allowed access to specific resources OpenID/OAuth OpenID is an authentication protocol that allows us to authenticate users without using a local auth system. In such a scenario, a user has to be registered with an OpenID Provider and the same provider should be integrated with the authentication flow of your application. To verify the details, we have to forward the authentication requests to the provider. On successful authentication, we receive a success message and/or profile details with which we can execute the necessary flow. OAuth is an authorization mechanism that allows your application user access to a provider(Gmail/Facebook/Instagram/etc). On successful response, we (your application) receive a token with which the application can access certain APIs on behalf of a user. OAuth is convenient in case your business use case requires some certain user-facing APIs like access to Google Drive or sending tweets on your behalf. Most OAuth 2.0 providers can be used for pseudo authentication. Having said that, it can get pretty complicated if you are using multiple OAuth providers to authenticate users on top of the local authentication system. Cryptography It is the science and study of hiding any text in such a way that only the intended recipients or authorized persons can read it and that any text can even use things such as invisible ink or the mechanical cryptography machines of the past. Cryptography is necessary for securing critical or proprietary information and is used to encode private data messages by converting some plain text into ciphertext. At its core, there are two ways of doing this, more advanced methods are all built upon. Ciphers Ciphers are the cornerstone of cryptography. A cipher is a set of algorithms that performs encryption or decryption on a message. An encryption algorithm (E) takes a secret key (k) and a message (m) and produces a ciphertext (c). Similarly, a Decryption algorithm (D) takes a secret key (K) and the previous resulting Ciphertext (C). They are represented as follows: E(k,m) = c D(k,c) = m This also means that for it to be a cipher, it must satisfy the consistency equation as follows, making it possible to decrypt. D(k,E(k,m)) = m Stream Ciphers: The message is broken into characters or bits and enciphered with a key or keystream(should be random and generated independently of the message stream) that is as long as the plaintext bitstream. If the keystream is random, this scheme would be unbreakable unless the keystream was acquired, making it unconditionally secure. The keystream must be provided to both parties in a secure way to prevent its release. Block Ciphers: Block ciphers \u2014 process messages in blocks, each of which is then encrypted or decrypted. A block cipher is a symmetric cipher in which blocks of plaintext are treated as a whole and used to produce ciphertext blocks. The block cipher takes blocks that are b bits long and encrypts them to blocks that are also b bits long. Block sizes are typically 64 or 128 bits long. Encryption Secret Key (Symmetric Key) : the same key is used for encryption and decryption Public Key (Asymmetric Key) in an asymmetric, the encryption and decryption keys are different but related. The encryption key is known as the public key and the decryption key is known as the private key. The public and private keys are known as a key pair. Symmetric Key Encryption DES The Data Encryption Standard (DES) has been the worldwide encryption standard for a long time. IBM developed DES in 1975, and it has held up remarkably well against years of cryptanalysis. DES is a symmetric encryption algorithm with a fixed key length of 56 bits. The algorithm is still good, but because of the short key length, it is susceptible to brute-force attacks that have sufficient resources. DES usually operates in block mode, whereby it encrypts data in 64-bit blocks. The same algorithm and key are used for both encryption and decryption. Because DES is based on simple mathematical functions, it can be easily implemented and accelerated in hardware. Triple DES With advances in computer processing power, the original 56-bit DES key became too short to withstand an attacker with even a limited budget. One way of increasing the effective key length of DES without changing the well-analyzed algorithm itself is to use the same algorithm with different keys several times in a row. The technique of applying DES three times in a row to a plain text block is called Triple DES (3DES). The 3DES technique is shown in Figure. Brute-force attacks on 3DES are considered unfeasible today. Because the basic algorithm has been tested in the field for more than 25 years, it is considered to be more trustworthy than its predecessor. AES On October 2, 2000, The U.S. National Institute of Standards and Technology (NIST) announced the selection of the Rijndael cipher as the AES algorithm. This cipher, developed by Joan Daemen and Vincent Rijmen, has a variable block length and key length. The algorithm currently specifies how to use keys with a length of 128, 192, or 256 bits to encrypt blocks with a length of 128, 192, or 256 bits (all nine combinations of key length and block length are possible). Both block and key lengths can be extended easily to multiples of 32 bits. AES was chosen to replace DES and 3DES because they are either too weak (DES, in terms of key length) or too slow (3DES) to run on modern, efficient hardware. AES is more efficient and much faster, usually by a factor of 5 compared to DES on the same hardware. AES is also more suitable for high throughput, especially if pure software encryption is used. However, AES is a relatively young algorithm, and as the golden rule of cryptography states, \u201cA more mature algorithm is always more trusted.\u201d Asymmetric Key Algorithm In a symmetric key system, Alice first puts the secret message in a box and then padlocks the box using a lock to which she has a key. She then sends the box to Bob through regular mail. When Bob receives the box, he uses an identical copy of Alice's key (which he has obtained previously) to open the box and read the message. In an asymmetric key system, instead of opening the box when he receives it, Bob simply adds his own personal lock to the box and returns the box through public mail to Alice. Alice uses her key to remove her lock and returns the box to Bob, with Bob's lock still in place. Finally, Bob uses his key to remove his lock and reads the message from Alice. The critical advantage in an asymmetric system is that Alice never needs to send a copy of her key to Bob. This reduces the possibility that a third party (for example, an unscrupulous postmaster) can copy the key while it is in transit to Bob, allowing that third party to spy on all future messages sent by Alice. In addition, if Bob is careless and allows someone else to copy his key, Alice's messages to Bob are compromised, but Alice's messages to other people remain secret NOTE : In terms of TLS key exchange, this is the common approach. Diffie-Hellman The protocol has two system parameters, p and g. They are both public and may be used by everybody. Parameter p is a prime number, and parameter g (usually called a generator) is an integer that is smaller than p, but with the following property: For every number n between 1 and p \u2013 1 inclusive, there is a power k of g such that n = gk mod p. Diffie Hellman algorithm is an asymmetric algorithm used to establish a shared secret for a symmetric key algorithm. Nowadays most of the people use hybrid cryptosystem i.e, a combination of symmetric and asymmetric encryption. Asymmetric Encryption is used as a technique in key exchange mechanism to share a secret key and after the key is shared between sender and receiver, the communication will take place using symmetric encryption. The shared secret key will be used to encrypt the communication. Refer: https://medium.com/@akhigbemmanuel/what-is-the-diffie-hellman-key-exchange-algorithm-84d60025a30d RSA The RSA algorithm is very flexible and has a variable key length where, if necessary, speed can be traded for the level of security of the algorithm. The RSA keys are usually 512 to 2048 bits long. RSA has withstood years of extensive cryptanalysis. Although those years neither proved nor disproved RSA's security, they attest to a confidence level in the algorithm. RSA security is based on the difficulty of factoring very large numbers. If an easy method of factoring these large numbers were discovered, the effectiveness of RSA would be destroyed. Refer: https://medium.com/curiositypapers/a-complete-explanation-of-rsa-asymmetric-encryption-742c5971e0f NOTE : RSA Keys can be used for key exchange just like Diffie Hellman Hashing Algorithms Hashing is one of the mechanisms used for data integrity assurance. Hashing is based on a one-way mathematical function, which is relatively easy to compute but significantly harder to reverse. A hash function, which is a one-way function to input data to produce a fixed-length digest (fingerprint) of output data. The digest is cryptographically strong; that is, it is impossible to recover input data from its digest. If the input data changes just a little, the digest (fingerprint) changes substantially in what is called an avalanche effect. More: https://medium.com/@rauljordan/the-state-of-hashing-algorithms-the-why-the-how-and-the-future-b21d5c0440de https://medium.com/@StevieCEllis/the-beautiful-hash-algorithm-f18d9d2b84fb MD5 MD5 is a one-way function with which it is easy to compute the hash from the given input data, but it is unfeasible to compute input data given only a hash. SHA-1 MD5 is considered less secure than SHA-1 because MD5 has some weaknesses. HA-1 also uses a stronger, 160-bit digest, which makes MD5 the second choice as hash methods are concerned. The algorithm takes a message of less than 264 bits in length and produces a 160-bit message digest. This algorithm is slightly slower than MD5. NOTE : SHA-1 is also recently demonstrated to be broken, Minimum current recommendation is SHA-256 Digital Certificates Digital signatures, provide a means to digitally authenticate devices and individual users. In public-key cryptography, such as the RSA encryption system, each user has a key-pair containing both a public key and a private key. The keys act as complements, and anything encrypted with one of the keys can be decrypted with the other. In simple terms, a signature is formed when data is encrypted with a user's private key. The receiver verifies the signature by decrypting the message with the sender's public key. Key management is often considered the most difficult task in designing and implementing cryptographic systems. Businesses can simplify some of the deployment and management issues that are encountered with secured data communications by employing a Public Key Infrastructure (PKI). Because corporations often move security-sensitive communications across the Internet, an effective mechanism must be implemented to protect sensitive information from the threats presented on the Internet. PKI provides a hierarchical framework for managing digital security attributes. Each PKI participant holds a digital certificate that has been issued by a CA (either public or private). The certificate contains several attributes that are used when parties negotiate a secure connection. These attributes must include the certificate validity period, end-host identity information, encryption keys that will be used for secure communications, and the signature of the issuing CA. Optional attributes may be included, depending on the requirements and capability of the PKI. A CA can be a trusted third party, such as VeriSign or Entrust, or a private (in-house) CA that you establish within your organization. The fact that the message could be decrypted using the sender's public key means that the holder of the private key created the message. This process relies on the receiver having a copy of the sender's public key and knowing with a high degree of certainty that it really does belong to the sender and not to someone pretending to be the sender. To validate the CA's signature, the receiver must know the CA's public key. Normally, this is handled out-of-band or through an operation performed during the installation of the certificate. For instance, most web browsers are configured with the root certificates of several CAs by default. CA Enrollment process The end host generates a private-public key pair. The end host generates a certificate request, which it forwards to the CA. Manual human intervention is required to approve the enrollment request, which is received by the CA. After the CA operator approves the request, the CA signs the certificate request with its private key and returns the completed certificate to the end host. The end host writes the certificate into a nonvolatile storage area (PC hard disk or NVRAM on Cisco routers). Refer : https://www.ssh.com/manuals/server-zos-product/55/ch06s03s01.html Login Security SSH SSH, the Secure Shell, is a popular, powerful, software-based approach to network security. Whenever data is sent by a computer to the network, SSH automatically encrypts (scrambles) it. Then, when the data reaches its intended recipient, SSH automatically decrypts (unscrambles) it. The result is transparent encryption: users can work normally, unaware that their communications are safely encrypted on the network. In addition, SSH can use modern, secure encryption algorithms based on how it's being configured and is effective enough to be found within mission-critical applications at major corporations. SSH has a client/server architecture An SSH server program, typically installed and run by a system administrator, accepts or rejects incoming connections to its host computer. Users then run SSH client programs, typically on other computers, to make requests of the SSH server, such as \u201cPlease log me in,\u201d \u201cPlease send me a file,\u201d or \u201cPlease execute this command.\u201d All communications between clients and servers are securely encrypted and protected from modification. What SSH is not: Although SSH stands for Secure Shell, it is not a true shell in the sense of the Unix Bourne shell and C shell. It is not a command interpreter, nor does it provide wildcard expansion, command history, and so forth. Rather, SSH creates a channel for running a shell on a remote computer, with end-to-end encryption between the two systems. The major features and guarantees of the SSH protocol are: Privacy of your data, via strong encryption Integrity of communications, guaranteeing they haven\u2019t been altered Authentication, i.e., proof of identity of senders and receivers Authorization, i.e., access control to accounts Forwarding or tunnelling to encrypt other TCP/IP-based sessions Kerberos According to Greek mythology Kerberos (Cerberus) was the gigantic, three-headed dog that guards the gates of the underworld to prevent the dead from leaving. So when it comes to Computer Science, Kerberos is a network authentication protocol and is currently the default authentication technology used by Microsoft Active Directory to authenticate users to services within a local area network. Kerberos uses symmetric-key cryptography and requires a trusted third-party authentication service to verify user identities. So they used the name of Kerberos for their computer network authentication protocol as the three heads of the Kerberos represent: a client: A user/ a service a server: Kerberos protected hosts reside - a Key Distribution Center (KDC), which acts as the trusted third-party authentication service. The KDC includes the following two servers: Authentication Server (AS) that performs the initial authentication and issues ticket-granting tickets (TGT) for users. Ticket-Granting Server (TGS) that issues service tickets that are based on the initial ticket-granting tickets (TGT). Certificate Chain The first part of the output of the OpenSSL command shows three certificates numbered 0, 1, and 2(not 2 anymore). Each certificate has a subject, s, and an issuer, i. The first certificate, number 0, is called the end-entity certificate. The subject line tells us it\u2019s valid for any subdomain of google.com because its subject is set to *.google.com. $ openssl s_client -connect www.google.com:443 -CApath /etc/ssl/certs CONNECTED(00000005) depth=2 OU = GlobalSign Root CA - R2, O = GlobalSign, CN = GlobalSign verify return:1 depth=1 C = US, O = Google Trust Services, CN = GTS CA 1O1 verify return:1 depth=0 C = US, ST = California, L = Mountain View, O = Google LLC, CN = www.google.com verify return:1 --- Certificate chain 0 s:/C=US/ST=California/L=Mountain View/O=Google LLC/CN=www.google.com i:/C=US/O=Google Trust Services/CN=GTS CA 1O1 1 s:/C=US/O=Google Trust Services/CN=GTS CA 1O1 i:/OU=GlobalSign Root CA - R2/O=GlobalSign/CN=GlobalSign --- Server certificate The issuer line indicates it\u2019s issued by Google Internet Authority G2, which also happens to be the subject of the second certificate, number 1 What the OpenSSL command line doesn\u2019t show here is the trust store that contains the list of CA certificates trusted by the system OpenSSL runs on. The public certificate of GlobalSign Authority must be present in the system\u2019s trust store to close the verification chain. This is called a chain of trust, and the figure below summarizes its behaviour at a high level. High-level view of the concept of chain of trust applied to verifying the authenticity of a website. The Root CA in the Firefox trust store provides the initial trust to verify the entire chain and trust the end-entity certificate. TLS Handshake The client sends a HELLO message to the server with a list of protocols and algorithms it supports. The server says HELLO back and sends its chain of certificates. Based on the capabilities of the client, the server picks a cipher suite. If the cipher suite supports ephemeral key exchange, like ECDHE does(ECDHE is an algorithm known as the Elliptic Curve Diffie-Hellman Exchange), the server and the client negotiate a pre-master key with the Diffie-Hellman algorithm. The pre-master key is never sent over the wire. The client and server create a session key that will be used to encrypt the data transiting through the connection. At the end of the handshake, both parties possess a secret session key used to encrypt data for the rest of the connection. This is what OpenSSL refers to as Master-Key NOTE There are 3 versions of TLS , TLS 1.0, 1.1 & 1.2 TLS 1.0 was released in 1999, making it a nearly two-decade-old protocol. It has been known to be vulnerable to attacks\u2014such as BEAST and POODLE\u2014for years, in addition to supporting weak cryptography, which doesn\u2019t keep modern-day connections sufficiently secure. TLS 1.1 is the forgotten \u201cmiddle child.\u201d It also has bad cryptography like its younger sibling. In most software, it was leapfrogged by TLS 1.2 and it\u2019s rare to see TLS 1.1 used. \u201cPerfect\u201d Forward Secrecy The term \u201cephemeral\u201d in the key exchange provides an important security feature mis-named perfect forward secrecy (PFS) or just \u201cForward Secrecy\u201d. In a non-ephemeral key exchange, the client sends the pre-master key to the server by encrypting it with the server\u2019s public key. The server then decrypts the pre-master key with its private key. If at a later point in time, the private key of the server is compromised, an attacker can go back to this handshake, decrypt the pre-master key, obtain the session key, and decrypt the entire traffic. Non-ephemeral key exchanges are vulnerable to attacks that may happen in the future on recorded traffic. And because people seldom change their password, decrypting data from the past may still be valuable for an attacker. An ephemeral key exchange like DHE, or its variant on elliptic curve, ECDHE, solves this problem by not transmitting the pre-master key over the wire. Instead, the pre-master key is computed by both the client and the server in isolation, using nonsensitive information exchanged publicly. Because the pre-master key can\u2019t be decrypted later by an attacker, the session key is safe from future attacks: hence, the term perfect forward secrecy. Keys are changed every X blocks along the stream. That prevents an attacker from simply sniffing the stream and applying brute force to crack the whole thing. \"Forward secrecy\" means that just because I can decrypt block M, does not mean that I can decrypt block Q Downside: The downside to PFS is that all those extra computational steps induce latency on the handshake and slow the user down. To avoid repeating this expensive work at every connection, both sides cache the session key for future use via a technique called session resumption. This is what the session-ID and TLS ticket are for: they allow a client and server that share a session ID to skip over the negotiation of a session key, because they already agreed on one previously, and go directly to exchanging data securely.","title":"Fundamentals of Security"},{"location":"level101/security/fundamentals/#part-i-fundamentals","text":"","title":"Part I: Fundamentals"},{"location":"level101/security/fundamentals/#introduction-to-security-overview-for-sre","text":"If you look closely, both Site Reliability Engineering and Security Engineering are concerned with keeping a system usable. Issues like broken releases, capacity shortages, and misconfigurations can make a system unusable (at least temporarily). Security or privacy incidents that break the trust of users also undermine the usefulness of a system. Consequently, system security should be top of mind for SREs. SREs should be involved in both significant design discussions and actual system changes. They have quite a big role in System design & hence are quite sometimes the first line of defence. SRE\u2019s help in preventing bad design & implementations which can affect the overall security of the infrastructure. Successfully designing, implementing, and maintaining systems requires a commitment to the full system lifecycle . This commitment is possible only when security and reliability are central elements in the architecture of systems. Core Pillars of Information Security : Confidentiality \u2013 only allow access to data for which the user is permitted Integrity \u2013 ensure data is not tampered or altered by unauthorized users Availability \u2013 ensure systems and data are available to authorized users when they need it Thinking like a Security Engineer When starting a new application or re-factoring an existing application, you should consider each functional feature, and consider: Is the process surrounding this feature as safe as possible? In other words, is this a flawed process? If I were evil, how would I abuse this feature? Or more specifically failing to address how a feature can be abused can cause design flaws. Is the feature required to be on by default? If so, are there limits or options that could help reduce the risk from this feature? Security Principles By OWASP (Open Web Application Security Project) Minimize attack surface area : Every feature that is added to an application adds a certain amount of risk to the overall application. The aim of secure development is to reduce the overall risk by reducing the attack surface area. For example, a web application implements online help with a search function. The search function may be vulnerable to SQL injection attacks. If the help feature was limited to authorized users, the attack likelihood is reduced. If the help feature\u2019s search function was gated through centralized data validation routines, the ability to perform SQL injection is dramatically reduced. However, if the help feature was re-written to eliminate the search function (through a better user interface, for example), this almost eliminates the attack surface area, even if the help feature was available to the Internet at large. Establish secure defaults: There are many ways to deliver an \u201cout of the box\u201d experience for users. However, by default, the experience should be secure, and it should be up to the user to reduce their security \u2013 if they are allowed. For example, by default, password ageing and complexity should be enabled. Users might be allowed to turn these two features off to simplify their use of the application and increase their risk. Default Passwords of routers, IoT devices should be changed Principle of Least privilege The principle of least privilege recommends that accounts have the least amount of privilege required to perform their business processes. This encompasses user rights, resource permissions such as CPU limits, memory, network, and file system permissions. For example, if a middleware server only requires access to the network, read access to a database table, and the ability to write to a log, this describes all the permissions that should be granted. Under no circumstances should the middleware be granted administrative privileges. Principle of Defense in depth The principle of defence in depth suggests that where one control would be reasonable, more controls that approach risks in different fashions are better. Controls, when used in depth, can make severe vulnerabilities extraordinarily difficult to exploit and thus unlikely to occur. With secure coding, this may take the form of tier-based validation, centralized auditing controls, and requiring users to be logged on all pages. For example, a flawed administrative interface is unlikely to be vulnerable to an anonymous attack if it correctly gates access to production management networks, checks for administrative user authorization, and logs all access. Fail securely Applications regularly fail to process transactions for many reasons. How they fail can determine if an application is secure or not. ``` is_admin = true; try { code_which_may_faile(); is_admin = is_user_assigned_role(\"Adminstrator\"); } catch (Exception err) { log.error(err.toString()); } ``` - If either codeWhichMayFail() or isUserInRole fails or throws an exception, the user is an admin by default. This is obviously a security risk. Don\u2019t trust services Many organizations utilize the processing capabilities of third-party partners, who more than likely have different security policies and posture than you. It is unlikely that you can influence or control any external third party, whether they are home users or major suppliers or partners. Therefore, the implicit trust of externally run systems is not warranted. All external systems should be treated similarly. For example, a loyalty program provider provides data that is used by Internet Banking, providing the number of reward points and a small list of potential redemption items. However, the data should be checked to ensure that it is safe to display to end-users and that the reward points are a positive number, and not improbably large. Separation of duties The key to fraud control is the separation of duties. For example, someone who requests a computer cannot also sign for it, nor should they directly receive the computer. This prevents the user from requesting many computers and claiming they never arrived. Certain roles have different levels of trust than normal users. In particular, administrators are different from normal users. In general, administrators should not be users of the application. For example, an administrator should be able to turn the system on or off, set password policy but shouldn\u2019t be able to log on to the storefront as a super privileged user, such as being able to \u201cbuy\u201d goods on behalf of other users. Avoid security by obscurity Security through obscurity is a weak security control, and nearly always fails when it is the only control. This is not to say that keeping secrets is a bad idea, it simply means that the security of systems should not be reliant upon keeping details hidden. For example, the security of an application should not rely upon knowledge of the source code being kept secret. The security should rely upon many other factors, including reasonable password policies, defence in depth, business transaction limits, solid network architecture, and fraud, and audit controls. A practical example is Linux. Linux\u2019s source code is widely available, and yet when properly secured, Linux is a secure and robust operating system. Keep security simple Attack surface area and simplicity go hand in hand. Certain software engineering practices prefer overly complex approaches to what would otherwise be a relatively straightforward and simple design. Developers should avoid the use of double negatives and complex architectures when a simpler approach would be faster and simpler. For example, although it might be fashionable to have a slew of singleton entity beans running on a separate middleware server, it is more secure and faster to simply use global variables with an appropriate mutex mechanism to protect against race conditions. Fix security issues correctly Once a security issue has been identified, it is important to develop a test for it and to understand the root cause of the issue. When design patterns are used, the security issue is likely widespread amongst all codebases, so developing the right fix without introducing regressions is essential. For example, a user has found that they can see another user\u2019s balance by adjusting their cookie. The fix seems to be relatively straightforward, but as the cookie handling code is shared among all applications, a change to just one application will trickle through to all other applications. The fix must, therefore, be tested on all affected applications. Reliability & Security Reliability and security are both crucial components of a truly trustworthy system, but building systems that are both reliable and secure is difficult. While the requirements for reliability and security share many common properties, they also require different design considerations. It is easy to miss the subtle interplay between reliability and security that can cause unexpected outcomes Ex: A password management application failure was triggered by a reliability problem i.e poor load-balancing and load-shedding strategies and its recovery were later complicated by multiple measures (HSM mechanism which needs to be plugged into server racks, which works as an authentication & the HSM token supposedly locked inside a case.. & the problem can be further elongated ) designed to increase the security of the system.","title":"Introduction to Security Overview for SRE"},{"location":"level101/security/fundamentals/#authentication-vs-authorization","text":"Authentication is the act of validating that users are who they claim to be. Passwords are the most common authentication factor\u2014if a user enters the correct password, the system assumes the identity is valid and grants access. Other technologies such as One-Time Pins, authentication apps, and even biometrics can also be used to authenticate identity. In some instances, systems require the successful verification of more than one factor before granting access. This multi-factor authentication (MFA) requirement is often deployed to increase security beyond what passwords alone can provide. Authorization in system security is the process of giving the user permission to access a specific resource or function. This term is often used interchangeably with access control or client privilege. Giving someone permission to download a particular file on a server or providing individual users with administrative access to an application are good examples. In secure environments, authorization must always follow authentication, users should first prove that their identities are genuine before an organization\u2019s administrators grant them access to the requested resources.","title":"Authentication vs Authorization"},{"location":"level101/security/fundamentals/#common-authentication-flow-local-authentication","text":"The user registers using an identifier like username/email/mobile The application stores user credentials in the database The application sends a verification email/message to validate the registration Post successful registration, the user enters credentials for logging in On successful authentication, the user is allowed access to specific resources","title":"Common authentication flow (local authentication)"},{"location":"level101/security/fundamentals/#openidoauth","text":"OpenID is an authentication protocol that allows us to authenticate users without using a local auth system. In such a scenario, a user has to be registered with an OpenID Provider and the same provider should be integrated with the authentication flow of your application. To verify the details, we have to forward the authentication requests to the provider. On successful authentication, we receive a success message and/or profile details with which we can execute the necessary flow. OAuth is an authorization mechanism that allows your application user access to a provider(Gmail/Facebook/Instagram/etc). On successful response, we (your application) receive a token with which the application can access certain APIs on behalf of a user. OAuth is convenient in case your business use case requires some certain user-facing APIs like access to Google Drive or sending tweets on your behalf. Most OAuth 2.0 providers can be used for pseudo authentication. Having said that, it can get pretty complicated if you are using multiple OAuth providers to authenticate users on top of the local authentication system.","title":"OpenID/OAuth"},{"location":"level101/security/fundamentals/#cryptography","text":"It is the science and study of hiding any text in such a way that only the intended recipients or authorized persons can read it and that any text can even use things such as invisible ink or the mechanical cryptography machines of the past. Cryptography is necessary for securing critical or proprietary information and is used to encode private data messages by converting some plain text into ciphertext. At its core, there are two ways of doing this, more advanced methods are all built upon.","title":"Cryptography"},{"location":"level101/security/fundamentals/#ciphers","text":"Ciphers are the cornerstone of cryptography. A cipher is a set of algorithms that performs encryption or decryption on a message. An encryption algorithm (E) takes a secret key (k) and a message (m) and produces a ciphertext (c). Similarly, a Decryption algorithm (D) takes a secret key (K) and the previous resulting Ciphertext (C). They are represented as follows: E(k,m) = c D(k,c) = m This also means that for it to be a cipher, it must satisfy the consistency equation as follows, making it possible to decrypt. D(k,E(k,m)) = m Stream Ciphers: The message is broken into characters or bits and enciphered with a key or keystream(should be random and generated independently of the message stream) that is as long as the plaintext bitstream. If the keystream is random, this scheme would be unbreakable unless the keystream was acquired, making it unconditionally secure. The keystream must be provided to both parties in a secure way to prevent its release. Block Ciphers: Block ciphers \u2014 process messages in blocks, each of which is then encrypted or decrypted. A block cipher is a symmetric cipher in which blocks of plaintext are treated as a whole and used to produce ciphertext blocks. The block cipher takes blocks that are b bits long and encrypts them to blocks that are also b bits long. Block sizes are typically 64 or 128 bits long. Encryption Secret Key (Symmetric Key) : the same key is used for encryption and decryption Public Key (Asymmetric Key) in an asymmetric, the encryption and decryption keys are different but related. The encryption key is known as the public key and the decryption key is known as the private key. The public and private keys are known as a key pair. Symmetric Key Encryption DES The Data Encryption Standard (DES) has been the worldwide encryption standard for a long time. IBM developed DES in 1975, and it has held up remarkably well against years of cryptanalysis. DES is a symmetric encryption algorithm with a fixed key length of 56 bits. The algorithm is still good, but because of the short key length, it is susceptible to brute-force attacks that have sufficient resources. DES usually operates in block mode, whereby it encrypts data in 64-bit blocks. The same algorithm and key are used for both encryption and decryption. Because DES is based on simple mathematical functions, it can be easily implemented and accelerated in hardware. Triple DES With advances in computer processing power, the original 56-bit DES key became too short to withstand an attacker with even a limited budget. One way of increasing the effective key length of DES without changing the well-analyzed algorithm itself is to use the same algorithm with different keys several times in a row. The technique of applying DES three times in a row to a plain text block is called Triple DES (3DES). The 3DES technique is shown in Figure. Brute-force attacks on 3DES are considered unfeasible today. Because the basic algorithm has been tested in the field for more than 25 years, it is considered to be more trustworthy than its predecessor. AES On October 2, 2000, The U.S. National Institute of Standards and Technology (NIST) announced the selection of the Rijndael cipher as the AES algorithm. This cipher, developed by Joan Daemen and Vincent Rijmen, has a variable block length and key length. The algorithm currently specifies how to use keys with a length of 128, 192, or 256 bits to encrypt blocks with a length of 128, 192, or 256 bits (all nine combinations of key length and block length are possible). Both block and key lengths can be extended easily to multiples of 32 bits. AES was chosen to replace DES and 3DES because they are either too weak (DES, in terms of key length) or too slow (3DES) to run on modern, efficient hardware. AES is more efficient and much faster, usually by a factor of 5 compared to DES on the same hardware. AES is also more suitable for high throughput, especially if pure software encryption is used. However, AES is a relatively young algorithm, and as the golden rule of cryptography states, \u201cA more mature algorithm is always more trusted.\u201d Asymmetric Key Algorithm In a symmetric key system, Alice first puts the secret message in a box and then padlocks the box using a lock to which she has a key. She then sends the box to Bob through regular mail. When Bob receives the box, he uses an identical copy of Alice's key (which he has obtained previously) to open the box and read the message. In an asymmetric key system, instead of opening the box when he receives it, Bob simply adds his own personal lock to the box and returns the box through public mail to Alice. Alice uses her key to remove her lock and returns the box to Bob, with Bob's lock still in place. Finally, Bob uses his key to remove his lock and reads the message from Alice. The critical advantage in an asymmetric system is that Alice never needs to send a copy of her key to Bob. This reduces the possibility that a third party (for example, an unscrupulous postmaster) can copy the key while it is in transit to Bob, allowing that third party to spy on all future messages sent by Alice. In addition, if Bob is careless and allows someone else to copy his key, Alice's messages to Bob are compromised, but Alice's messages to other people remain secret NOTE : In terms of TLS key exchange, this is the common approach. Diffie-Hellman The protocol has two system parameters, p and g. They are both public and may be used by everybody. Parameter p is a prime number, and parameter g (usually called a generator) is an integer that is smaller than p, but with the following property: For every number n between 1 and p \u2013 1 inclusive, there is a power k of g such that n = gk mod p. Diffie Hellman algorithm is an asymmetric algorithm used to establish a shared secret for a symmetric key algorithm. Nowadays most of the people use hybrid cryptosystem i.e, a combination of symmetric and asymmetric encryption. Asymmetric Encryption is used as a technique in key exchange mechanism to share a secret key and after the key is shared between sender and receiver, the communication will take place using symmetric encryption. The shared secret key will be used to encrypt the communication. Refer: https://medium.com/@akhigbemmanuel/what-is-the-diffie-hellman-key-exchange-algorithm-84d60025a30d RSA The RSA algorithm is very flexible and has a variable key length where, if necessary, speed can be traded for the level of security of the algorithm. The RSA keys are usually 512 to 2048 bits long. RSA has withstood years of extensive cryptanalysis. Although those years neither proved nor disproved RSA's security, they attest to a confidence level in the algorithm. RSA security is based on the difficulty of factoring very large numbers. If an easy method of factoring these large numbers were discovered, the effectiveness of RSA would be destroyed. Refer: https://medium.com/curiositypapers/a-complete-explanation-of-rsa-asymmetric-encryption-742c5971e0f NOTE : RSA Keys can be used for key exchange just like Diffie Hellman Hashing Algorithms Hashing is one of the mechanisms used for data integrity assurance. Hashing is based on a one-way mathematical function, which is relatively easy to compute but significantly harder to reverse. A hash function, which is a one-way function to input data to produce a fixed-length digest (fingerprint) of output data. The digest is cryptographically strong; that is, it is impossible to recover input data from its digest. If the input data changes just a little, the digest (fingerprint) changes substantially in what is called an avalanche effect. More: https://medium.com/@rauljordan/the-state-of-hashing-algorithms-the-why-the-how-and-the-future-b21d5c0440de https://medium.com/@StevieCEllis/the-beautiful-hash-algorithm-f18d9d2b84fb MD5 MD5 is a one-way function with which it is easy to compute the hash from the given input data, but it is unfeasible to compute input data given only a hash. SHA-1 MD5 is considered less secure than SHA-1 because MD5 has some weaknesses. HA-1 also uses a stronger, 160-bit digest, which makes MD5 the second choice as hash methods are concerned. The algorithm takes a message of less than 264 bits in length and produces a 160-bit message digest. This algorithm is slightly slower than MD5. NOTE : SHA-1 is also recently demonstrated to be broken, Minimum current recommendation is SHA-256 Digital Certificates Digital signatures, provide a means to digitally authenticate devices and individual users. In public-key cryptography, such as the RSA encryption system, each user has a key-pair containing both a public key and a private key. The keys act as complements, and anything encrypted with one of the keys can be decrypted with the other. In simple terms, a signature is formed when data is encrypted with a user's private key. The receiver verifies the signature by decrypting the message with the sender's public key. Key management is often considered the most difficult task in designing and implementing cryptographic systems. Businesses can simplify some of the deployment and management issues that are encountered with secured data communications by employing a Public Key Infrastructure (PKI). Because corporations often move security-sensitive communications across the Internet, an effective mechanism must be implemented to protect sensitive information from the threats presented on the Internet. PKI provides a hierarchical framework for managing digital security attributes. Each PKI participant holds a digital certificate that has been issued by a CA (either public or private). The certificate contains several attributes that are used when parties negotiate a secure connection. These attributes must include the certificate validity period, end-host identity information, encryption keys that will be used for secure communications, and the signature of the issuing CA. Optional attributes may be included, depending on the requirements and capability of the PKI. A CA can be a trusted third party, such as VeriSign or Entrust, or a private (in-house) CA that you establish within your organization. The fact that the message could be decrypted using the sender's public key means that the holder of the private key created the message. This process relies on the receiver having a copy of the sender's public key and knowing with a high degree of certainty that it really does belong to the sender and not to someone pretending to be the sender. To validate the CA's signature, the receiver must know the CA's public key. Normally, this is handled out-of-band or through an operation performed during the installation of the certificate. For instance, most web browsers are configured with the root certificates of several CAs by default. CA Enrollment process The end host generates a private-public key pair. The end host generates a certificate request, which it forwards to the CA. Manual human intervention is required to approve the enrollment request, which is received by the CA. After the CA operator approves the request, the CA signs the certificate request with its private key and returns the completed certificate to the end host. The end host writes the certificate into a nonvolatile storage area (PC hard disk or NVRAM on Cisco routers). Refer : https://www.ssh.com/manuals/server-zos-product/55/ch06s03s01.html","title":"Ciphers"},{"location":"level101/security/fundamentals/#login-security","text":"","title":"Login Security"},{"location":"level101/security/fundamentals/#ssh","text":"SSH, the Secure Shell, is a popular, powerful, software-based approach to network security. Whenever data is sent by a computer to the network, SSH automatically encrypts (scrambles) it. Then, when the data reaches its intended recipient, SSH automatically decrypts (unscrambles) it. The result is transparent encryption: users can work normally, unaware that their communications are safely encrypted on the network. In addition, SSH can use modern, secure encryption algorithms based on how it's being configured and is effective enough to be found within mission-critical applications at major corporations. SSH has a client/server architecture An SSH server program, typically installed and run by a system administrator, accepts or rejects incoming connections to its host computer. Users then run SSH client programs, typically on other computers, to make requests of the SSH server, such as \u201cPlease log me in,\u201d \u201cPlease send me a file,\u201d or \u201cPlease execute this command.\u201d All communications between clients and servers are securely encrypted and protected from modification. What SSH is not: Although SSH stands for Secure Shell, it is not a true shell in the sense of the Unix Bourne shell and C shell. It is not a command interpreter, nor does it provide wildcard expansion, command history, and so forth. Rather, SSH creates a channel for running a shell on a remote computer, with end-to-end encryption between the two systems. The major features and guarantees of the SSH protocol are: Privacy of your data, via strong encryption Integrity of communications, guaranteeing they haven\u2019t been altered Authentication, i.e., proof of identity of senders and receivers Authorization, i.e., access control to accounts Forwarding or tunnelling to encrypt other TCP/IP-based sessions","title":"SSH"},{"location":"level101/security/fundamentals/#kerberos","text":"According to Greek mythology Kerberos (Cerberus) was the gigantic, three-headed dog that guards the gates of the underworld to prevent the dead from leaving. So when it comes to Computer Science, Kerberos is a network authentication protocol and is currently the default authentication technology used by Microsoft Active Directory to authenticate users to services within a local area network. Kerberos uses symmetric-key cryptography and requires a trusted third-party authentication service to verify user identities. So they used the name of Kerberos for their computer network authentication protocol as the three heads of the Kerberos represent: a client: A user/ a service a server: Kerberos protected hosts reside - a Key Distribution Center (KDC), which acts as the trusted third-party authentication service. The KDC includes the following two servers: Authentication Server (AS) that performs the initial authentication and issues ticket-granting tickets (TGT) for users. Ticket-Granting Server (TGS) that issues service tickets that are based on the initial ticket-granting tickets (TGT).","title":"Kerberos"},{"location":"level101/security/fundamentals/#certificate-chain","text":"The first part of the output of the OpenSSL command shows three certificates numbered 0, 1, and 2(not 2 anymore). Each certificate has a subject, s, and an issuer, i. The first certificate, number 0, is called the end-entity certificate. The subject line tells us it\u2019s valid for any subdomain of google.com because its subject is set to *.google.com. $ openssl s_client -connect www.google.com:443 -CApath /etc/ssl/certs CONNECTED(00000005) depth=2 OU = GlobalSign Root CA - R2, O = GlobalSign, CN = GlobalSign verify return:1 depth=1 C = US, O = Google Trust Services, CN = GTS CA 1O1 verify return:1 depth=0 C = US, ST = California, L = Mountain View, O = Google LLC, CN = www.google.com verify return:1 --- Certificate chain 0 s:/C=US/ST=California/L=Mountain View/O=Google LLC/CN=www.google.com i:/C=US/O=Google Trust Services/CN=GTS CA 1O1 1 s:/C=US/O=Google Trust Services/CN=GTS CA 1O1 i:/OU=GlobalSign Root CA - R2/O=GlobalSign/CN=GlobalSign --- Server certificate The issuer line indicates it\u2019s issued by Google Internet Authority G2, which also happens to be the subject of the second certificate, number 1 What the OpenSSL command line doesn\u2019t show here is the trust store that contains the list of CA certificates trusted by the system OpenSSL runs on. The public certificate of GlobalSign Authority must be present in the system\u2019s trust store to close the verification chain. This is called a chain of trust, and the figure below summarizes its behaviour at a high level. High-level view of the concept of chain of trust applied to verifying the authenticity of a website. The Root CA in the Firefox trust store provides the initial trust to verify the entire chain and trust the end-entity certificate.","title":"Certificate Chain"},{"location":"level101/security/fundamentals/#tls-handshake","text":"The client sends a HELLO message to the server with a list of protocols and algorithms it supports. The server says HELLO back and sends its chain of certificates. Based on the capabilities of the client, the server picks a cipher suite. If the cipher suite supports ephemeral key exchange, like ECDHE does(ECDHE is an algorithm known as the Elliptic Curve Diffie-Hellman Exchange), the server and the client negotiate a pre-master key with the Diffie-Hellman algorithm. The pre-master key is never sent over the wire. The client and server create a session key that will be used to encrypt the data transiting through the connection. At the end of the handshake, both parties possess a secret session key used to encrypt data for the rest of the connection. This is what OpenSSL refers to as Master-Key NOTE There are 3 versions of TLS , TLS 1.0, 1.1 & 1.2 TLS 1.0 was released in 1999, making it a nearly two-decade-old protocol. It has been known to be vulnerable to attacks\u2014such as BEAST and POODLE\u2014for years, in addition to supporting weak cryptography, which doesn\u2019t keep modern-day connections sufficiently secure. TLS 1.1 is the forgotten \u201cmiddle child.\u201d It also has bad cryptography like its younger sibling. In most software, it was leapfrogged by TLS 1.2 and it\u2019s rare to see TLS 1.1 used.","title":"TLS Handshake"},{"location":"level101/security/fundamentals/#perfect-forward-secrecy","text":"The term \u201cephemeral\u201d in the key exchange provides an important security feature mis-named perfect forward secrecy (PFS) or just \u201cForward Secrecy\u201d. In a non-ephemeral key exchange, the client sends the pre-master key to the server by encrypting it with the server\u2019s public key. The server then decrypts the pre-master key with its private key. If at a later point in time, the private key of the server is compromised, an attacker can go back to this handshake, decrypt the pre-master key, obtain the session key, and decrypt the entire traffic. Non-ephemeral key exchanges are vulnerable to attacks that may happen in the future on recorded traffic. And because people seldom change their password, decrypting data from the past may still be valuable for an attacker. An ephemeral key exchange like DHE, or its variant on elliptic curve, ECDHE, solves this problem by not transmitting the pre-master key over the wire. Instead, the pre-master key is computed by both the client and the server in isolation, using nonsensitive information exchanged publicly. Because the pre-master key can\u2019t be decrypted later by an attacker, the session key is safe from future attacks: hence, the term perfect forward secrecy. Keys are changed every X blocks along the stream. That prevents an attacker from simply sniffing the stream and applying brute force to crack the whole thing. \"Forward secrecy\" means that just because I can decrypt block M, does not mean that I can decrypt block Q Downside: The downside to PFS is that all those extra computational steps induce latency on the handshake and slow the user down. To avoid repeating this expensive work at every connection, both sides cache the session key for future use via a technique called session resumption. This is what the session-ID and TLS ticket are for: they allow a client and server that share a session ID to skip over the negotiation of a session key, because they already agreed on one previously, and go directly to exchanging data securely.","title":"\u201cPerfect\u201d Forward Secrecy"},{"location":"level101/security/intro/","text":"Security Prerequisites Linux Basics Linux Networking What to expect from this course The course covers fundamentals of information security along with touching on subjects of system security, network & web security. This course aims to get you familiar with the basics of information security in day to day operations & then as an SRE develop the mindset of ensuring that security takes a front-seat while developing solutions. The course also serves as an introduction to common risks and best practices along with practical ways to find out vulnerable systems and loopholes which might become compromised if not secured. What is not covered under this course The courseware is not an ethical hacking workshop or a very deep dive into the fundamentals of the problems. The course does not deal with hacking or breaking into systems but rather an approach on how to ensure you don\u2019t get into those situations and also to make you aware of different ways a system can be compromised. Course Contents Fundamentals Network Security Threats, Attacks & Defence Writing Secure Code & More Conclusion","title":"Introduction"},{"location":"level101/security/intro/#security","text":"","title":"Security"},{"location":"level101/security/intro/#prerequisites","text":"Linux Basics Linux Networking","title":"Prerequisites"},{"location":"level101/security/intro/#what-to-expect-from-this-course","text":"The course covers fundamentals of information security along with touching on subjects of system security, network & web security. This course aims to get you familiar with the basics of information security in day to day operations & then as an SRE develop the mindset of ensuring that security takes a front-seat while developing solutions. The course also serves as an introduction to common risks and best practices along with practical ways to find out vulnerable systems and loopholes which might become compromised if not secured.","title":"What to expect from this course"},{"location":"level101/security/intro/#what-is-not-covered-under-this-course","text":"The courseware is not an ethical hacking workshop or a very deep dive into the fundamentals of the problems. The course does not deal with hacking or breaking into systems but rather an approach on how to ensure you don\u2019t get into those situations and also to make you aware of different ways a system can be compromised.","title":"What is not covered under this course"},{"location":"level101/security/intro/#course-contents","text":"Fundamentals Network Security Threats, Attacks & Defence Writing Secure Code & More Conclusion","title":"Course Contents"},{"location":"level101/security/network_security/","text":"Part II: Network Security Introduction TCP/IP is the dominant networking technology today. It is a five-layer architecture. These layers are, from top to bottom, the application layer, the transport layer (TCP), the network layer (IP), the data-link layer, and the physical layer. In addition to TCP/IP, there also are other networking technologies. For convenience, we use the OSI network model to represent non-TCP/IP network technologies. Different networks are interconnected using gateways. A gateway can be placed at any layer. The OSI model is a seven-layer architecture. The OSI architecture is similar to the TCP/IP architecture, except that the OSI model specifies two additional layers between the application layer and the transport layer in the TCP/IP architecture. These two layers are the presentation layer and the session layer. Figure 5.1 shows the relationship between the TCP/IP layers and the OSI layers. The application layer in TCP/IP corresponds to the application layer and the presentation layer in OSI. The transport layer in TCP/IP corresponds to the session layer and the transport layer in OSI. The remaining three layers in the TCP/IP architecture are one-to-one correspondent to the remaining three layers in the OSI model. Correspondence between layers of the TCP/IP architecture and the OSI model. Also shown are placements of cryptographic algorithms in network layers, where the dotted arrows indicate actual communications of cryptographic algorithms The functionalities of OSI layers are briefly described as follows: The application layer serves as an interface between applications and network programs. It supports application programs and end-user processing. Common application-layer programs include remote logins, file transfer, email, and Web browsing. The presentation layer is responsible for dealing with data that is formed differently. This protocol layer allows application-layer programs residing on different sides of a communication channel with different platforms to understand each other's data formats regardless of how they are presented. The session layer is responsible for creating, managing, and closing a communication connection. The transport layer is responsible for providing reliable connections, such as packet sequencing, traffic control, and congestion control. The network layer is responsible for routing device-independent data packets from the current hop to the next hop. The data-link layer is responsible for encapsulating device-independent data packets into device-dependent data frames. It has two sublayers: logical link control and media access control. The physical layer is responsible for transmitting device-dependent frames through some physical media. Starting from the application layer, data generated from an application program is passed down layer-by-layer to the physical layer. Data from the previous layer is enclosed in a new envelope at the current layer, where the data from the previous layer is also just an envelope containing the data from the layer before it. This is similar to enclosing a smaller envelope in a larger one. The envelope added at each layer contains sufficient information for handling the packet. Application-layer data are divided into blocks small enough to be encapsulated in an envelope at the next layer. Application data blocks are \u201cdressed up\u201d in the TCP/IP architecture according to the following basic steps. At the sending side, an application data block is encapsulated in a TCP packet when it is passed down to the TCP layer. In other words, a TCP packet consists of a header and a payload, where the header corresponds to the TCP envelope and the payload is the application data block. Likewise, the TCP packet will be encapsulated in an IP packet when it is passed down to the IP layer. An IP packet consists of a header and a payload, which is the TCP packet passed down from the TCP layer. The IP packet will be encapsulated in a device-dependent frame (e.g., an Ethernet frame) when it is passed down to the data-link layer. A frame has a header, and it may also have a trailer. For example, in addition to having a header, an Ethernet frame also has a 32-bit cyclic redundancy check (CRC) trailer. When it is passed down to the physical layer, a frame will be transformed into a sequence of media signals for transmission Flow Diagram of a Packet Generation At the destination side, the medium signals are converted by the physical layer into a frame, which is passed up to the data-link layer. The data-link layer passes the frame payload (i.e., the IP packet encapsulated in the frame) up to the IP layer. The IP layer passes the IP payload, namely, the TCP packet encapsulated in the IP packet, up to the TCP layer. The TCP layer passes the TCP payload, namely, the application data block, up to the application layer. When a packet arrives at a router, it only goes up to the IP layer, where certain fields in the IP header are modified (e.g., the value of TTL is decreased by 1). This modified packet is then passed back down layer-by-layer to the physical layer for further transmission. Public Key Infrastructure To deploy cryptographic algorithms in network applications, we need a way to distribute secret keys using open networks. Public-key cryptography is the best way to distribute these secret keys. To use public-key cryptography, we need to build a public-key infrastructure (PKI) to support and manage public-key certificates and certificate authority (CA) networks. In particular, PKIs are set up to perform the following functions: Determine the legitimacy of users before issuing public-key certificates to them. Issue public-key certificates upon user requests. Extend public-key certificates valid time upon user requests. Revoke public-key certificates upon users' requests or when the corresponding private keys are compromised. Store and manage public-key certificates. Prevent digital signature signers from denying their signatures. Support CA networks to allow different CAs to authenticate public-key certificates issued by other CAs. X.509: https://certificatedecoder.dev/?gclid=EAIaIQobChMI0M731O6G6gIVVSQrCh04bQaAEAAYASAAEgKRkPD_BwE IPsec: A Security Protocol at the Network Layer IPsec is a major security protocol at the network layer IPsec provides a potent platform for constructing virtual private networks (VPN). VPNs are private networks overlayed on public networks. The purpose of deploying cryptographic algorithms at the network layer is to encrypt or authenticate IP packets (either just the payloads or the whole packets). IPsec also specifies how to exchange keys. Thus, IPsec consists of authentication protocols, encryption protocols, and key exchange protocols. They are referred to, respectively, as authentication header (AH), encapsulating security payload (ESP), and Internet key exchange (IKE). PGP & S/MIME : Email Security There are several security protocols at the application layer. The most used of these protocols are email security protocols namely PGP and S/MIME. SMTP (\u201cSimple Mail Transfer Protocol\u201d) is used for sending and delivering from a client to a server via port 25: it\u2019s the outgoing server. On the contrary, POP (\u201cPost Office Protocol\u201d) allows the users to pick up the message and download it into their inbox: it\u2019s the incoming server. The latest version of the Post Office Protocol is named POP3, and it\u2019s been used since 1996; it uses port 110 PGP PGP implements all major cryptographic algorithms, the ZIP compression algorithm, and the Base64 encoding algorithm. It can be used to authenticate a message, encrypt a message, or both. PGP follows the following general process: authentication, ZIP compression, encryption, and Base64 encoding. The Base64 encoding procedure makes the message ready for SMTP transmission GPG (GnuPG) GnuPG is another free encryption standard that companies may use that is based on OpenPGP. GnuPG serves as a replacement for Symantec\u2019s PGP. The main difference is the supported algorithms. However, GnuPG plays nice with PGP by design. Because GnuPG is open, some businesses would prefer the technical support and the user interface that comes with Symantec\u2019s PGP. It is important to note that there are some nuances between the compatibility of GnuPG and PGP, such as the compatibility between certain algorithms, but in most applications such as email, there are workarounds. One such algorithm is the IDEA Module which isn\u2019t included in GnuPG out of the box due to patent issues. S/MIME SMTP can only handle 7-bit ASCII text (You can use UTF-8 extensions to alleviate these limitations, ) messages. While POP can handle other content types besides 7-bit ASCII, POP may, under a common default setting, download all the messages stored in the mail server to the user's local computer. After that, if POP removes these messages from the mail server. This makes it difficult for the users to read their messages from multiple computers. The Multipurpose Internet Mail Extension protocol (MIME) was designed to support sending and receiving email messages in various formats, including nontext files generated by word processors, graphics files, sound files, and video clips. Moreover, MIME allows a single message to include mixed types of data in any combination of these formats. The Internet Mail Access Protocol (IMAP), operated on TCP port 143(only for non-encrypted), stores (Configurable on both server & client just like PoP) incoming email messages in the mail server until the user deletes them deliberately. This allows the users to access their mailbox from multiple machines and download messages to a local machine without deleting it from the mailbox in the mail server. SSL/TLS SSL uses a PKI to decide if a server\u2019s public key is trustworthy by requiring servers to use a security certificate signed by a trusted CA. When Netscape Navigator 1.0 was released, it trusted a single CA operated by the RSA Data Security corporation. The server\u2019s public RSA keys were used to be stored in the security certificate, which can then be used by the browser to establish a secure communication channel. The security certificates we use today still rely on the same standard (named X.509) that Netscape Navigator 1.0 used back then. Netscape intended to train users(though this didn\u2019t work out later) to differentiate secure communications from insecure ones, so they put a lock icon next to the address bar. When the lock is open, the communication is insecure. A closed lock means communication has been secured with SSL, which required the server to provide a signed certificate. You\u2019re obviously familiar with this icon as it\u2019s been in every browser ever since. The engineers at Netscape truly created a standard for secure internet communications. A year after releasing SSL 2.0, Netscape fixed several security issues and released SSL 3.0, a protocol that, albeit being officially deprecated since June 2015, remains in use in certain parts of the world more than 20 years after its introduction. To standardize SSL, the Internet Engineering Task Force (IETF) created a slightly modified SSL 3.0 and, in 1999, unveiled it as Transport Layer Security (TLS) 1.0. The name change between SSL and TLS continues to confuse people today. Officially, TLS is the new SSL, but in practice, people use SSL and TLS interchangeably to talk about any version of the protocol. Must See: https://tls.ulfheim.net/ https://davidwong.fr/tls13/ Network Perimeter Security Let us see how we keep a check on the perimeter i.e the edges, the first layer of protection General Firewall Framework Firewalls are needed because encryption algorithms cannot effectively stop malicious packets from getting into an edge network. This is because IP packets, regardless of whether they are encrypted, can always be forwarded into an edge network. Firewalls that were developed in the 1990s are important instruments to help restrict network access. A firewall may be a hardware device, a software package, or a combination of both. Packets flowing into the internal network from the outside should be evaluated before they are allowed to enter. One of the critical elements of a firewall is its ability to examine packets without imposing a negative impact on communication speed while providing security protections for the internal network. The packet inspection that is carried out by firewalls can be done using several different methods. Based on the particular method used by the firewall, it can be characterized as either a packet filter, circuit gateway, application gateway, or dynamic packet filter. Packet Filters It inspects ingress packets coming to an internal network from outside and inspects egress packets going outside from an internal network Packing filtering only inspects IP headers and TCP headers, not the payloads generated at the application layer A packet-filtering firewall uses a set of rules to determine whether a packet should be allowed or denied to pass through. 2 types: Stateless It treats each packet as an independent object, and it does not keep track of any previously processed packets. In other words, stateless filtering inspects a packet when it arrives and makes a decision without leaving any record of the packet being inspected. Stateful Stateful filtering, also referred to as connection-state filtering, keeps track of connections between an internal host and an external host. A connection state (or state, for short) indicates whether it is a TCP connection or a UDP connection and whether the connection is established. Circuit Gateways Circuit gateways, also referred to as circuit-level gateways, are typically operated at the transportation layer They evaluate the information of the IP addresses and the port numbers contained in TCP (or UDP) headers and use it to determine whether to allow or to disallow an internal host and an external host to establish a connection. It is common practice to combine packet filters and circuit gateways to form a dynamic packet filter (DPF). Application Gateways(ALG) Aka PROXY Servers An Application Level Gateway (ALG) acts as a proxy for internal hosts, processing service requests from external clients. An ALG performs deep inspections on each IP packet (ingress or egress). In particular, an ALG inspects application program formats contained in the packet (e.g., MIME format or SQL format) and examines whether its payload is permitted. Thus, an ALG may be able to detect a computer virus contained in the payload. Because an ALG inspects packet payloads, it may be able to detect malicious code and quarantine suspicious packets, in addition to blocking packets with suspicious IP addresses and TCP ports. On the other hand, an ALG also incurs substantial computation and space overheads. Trusted Systems & Bastion Hosts A Trusted Operating System (TOS) is an operating system that meets a particular set of security requirements. Whether an operating system can be trusted or not depends on several elements. For example, for an operating system on a particular computer to be certified trusted, one needs to validate that, among other things, the following four requirements are satisfied: Its system design contains no defects; Its system software contains no loopholes; Its system is configured properly; and Its system management is appropriate. Bastion Hosts Bastion hosts are computers with strong defence mechanisms. They often serve as host computers for implementing application gateways, circuit gateways, and other types of firewalls. A bastion host is operated on a trusted operating system that must not contain unnecessary functionalities or programs. This measure helps to reduce error probabilities and makes it easier to conduct security checks. Only those network application programs that are necessary, for example, SSH, DNS, SMTP, and authentication programs, are installed on a bastion host. Bastion hosts are also primarily used as controlled ingress points so that the security monitoring can focus more narrowly on actions happening at a single point closely. Common Techniques & Scannings, Packet Capturing Scanning Ports with Nmap Nmap (\"Network Mapper\") is a free and open-source (license) utility for network discovery and security auditing. Many systems and network administrators also find it useful for tasks such as network inventory, managing service upgrade schedules, and monitoring host or service uptime. The best thing about Nmap is it\u2019s free and open-source and is very flexible and versatile Nmap is often used to determine alive hosts in a network, open ports on those hosts, services running on those open ports, and version identification of that service on that port. More at http://scanme.nmap.org/ nmap [scan type] [options] [target specification] Nmap uses 6 different port states: Open \u2014 An open port is one that is actively accepting TCP, UDP or SCTP connections. Open ports are what interests us the most because they are the ones that are vulnerable to attacks. Open ports also show the available services on a network. Closed \u2014 A port that receives and responds to Nmap probe packets but there is no application listening on that port. Useful for identifying that the host exists and for OS detection. Filtered \u2014 Nmap can\u2019t determine whether the port is open because packet filtering prevents its probes from reaching the port. Filtering could come from firewalls or router rules. Often little information is given from filtered ports during scans as the filters can drop the probes without responding or respond with useless error messages e.g. destination unreachable. Unfiltered \u2014 Port is accessible but Nmap doesn\u2019t know if it is open or closed. Only used in ACK scan which is used to map firewall rulesets. Other scan types can be used to identify whether the port is open. Open/filtered \u2014 Nmap is unable to determine between open and filtered. This happens when an open port gives no response. No response could mean that the probe was dropped by a packet filter or any response is blocked. Closed/filtered \u2014 Nmap is unable to determine whether a port is closed or filtered. Only used in the IP ID idle scan. Types of Nmap Scan: TCP Connect TCP Connect scan completes the 3-way handshake. If a port is open, the operating system completes the TCP three-way handshake and the port scanner immediately closes the connection to avoid DOS. This is \u201cnoisy\u201d because the services can log the sender IP address and might trigger Intrusion Detection Systems. UDP Scan This scan checks to see if any UDP ports are listening. Since UDP does not respond with a positive acknowledgement like TCP and only responds to an incoming UDP packet when the port is closed, SYN Scan SYN scan is another form of TCP scanning. This scan type is also known as \u201chalf-open scanning\u201d because it never actually opens a full TCP connection. The port scanner generates a SYN packet. If the target port is open, it will respond with an SYN-ACK packet. The scanner host responds with an RST packet, closing the connection before the handshake is completed. If the port is closed but unfiltered, the target will instantly respond with an RST packet. SYN scan has the advantage that the individual services never actually receive a connection. FIN Scan This is a stealthy scan, like the SYN scan, but sends a TCP FIN packet instead. ACK Scan Ack scanning determines whether the port is filtered or not. Null Scan Another very stealthy scan that sets all the TCP header flags to off or null. This is not normally a valid packet and some hosts will not know what to do with this. XMAS Scan Similar to the NULL scan except for all the flags in the TCP header is set to on RPC Scan This special type of scan looks for machine answering to RPC (Remote Procedure Call) services IDLE Scan It is a super stealthy method whereby the scan packets are bounced off an external host. You don\u2019t need to have control over the other host but it does have to set up and meet certain requirements. You must input the IP address of our \u201czombie\u201d host and what port number to use. It is one of the more controversial options in Nmap since it only has a use for malicious attacks. Scan Techniques A couple of scan techniques which can be used to gain more information about a system and its ports. You can read more at https://medium.com/infosec-adventures/nmap-cheatsheet-a423fcdda0ca OpenVAS OpenVAS is a full-featured vulnerability scanner. OpenVAS is a framework of services and tools that provides a comprehensive and powerful vulnerability scanning and management package OpenVAS, which is an open-source program, began as a fork of the once-more-popular scanning program, Nessus. OpenVAS is made up of three main parts. These are: a regularly updated feed of Network Vulnerability Tests (NVTs); a scanner, which runs the NVTs; and an SQLite 3 database for storing both your test configurations and the NVTs\u2019 results and configurations. https://www.greenbone.net/en/install_use_gce/ WireShark Wireshark is a protocol analyzer. This means Wireshark is designed to decode not only packet bits and bytes but also the relations between packets and protocols. Wireshark understands protocol sequences. A simple demo of Wireshark Capture only udp packets: Capture filter = \u201cudp\u201d Capture only tcp packets Capture filter = \u201ctcp\u201d TCP/IP 3 way Handshake Filter by IP address: displays all traffic from IP, be it source or destination ip.addr == 192.168.1.1 Filter by source address: display traffic only from IP source ip.src == 192.168.0.1 Filter by destination: display traffic only form IP destination ip.dst == 192.168.0.1 Filter by IP subnet: display traffic from subnet, be it source or destination ip.addr = 192.168.0.1/24 Filter by protocol: filter traffic by protocol name dns http ftp arp ssh telnet icmp Exclude IP address: remove traffic from and to IP address !ip.addr ==192.168.0.1 Display traffic between two specific subnet ip.addr == 192.168.0.1/24 and ip.addr == 192.168.1.1/24 Display traffic between two specific workstations ip.addr == 192.168.0.1 and ip.addr == 192.168.0.2 Filter by MAC eth.addr = 00:50:7f:c5:b6:78 Filter TCP port tcp.port == 80 Filter TCP port source tcp.srcport == 80 Filter TCP port destination tcp.dstport == 80 Find user agents http.user_agent contains Firefox !http.user_agent contains || !http.user_agent contains Chrome Filter broadcast traffic !(arp or icmp or dns) Filter IP address and port tcp.port == 80 && ip.addr == 192.168.0.1 Filter all http get requests http.request Filter all http get requests and responses http.request or http.response Filter three way handshake tcp.flags.syn==1 or (tcp.seq==1 and tcp.ack==1 and tcp.len==0 and tcp.analysis.initial_rtt) Find files by type frame contains \u201c(attachment|tar|exe|zip|pdf)\u201d Find traffic based on keyword tcp contains facebook frame contains facebook Detecting SYN Floods tcp.flags.syn == 1 and tcp.flags.ack == 0 Wireshark Promiscuous Mode - By default, Wireshark only captures packets going to and from the computer where it runs. By checking the box to run Wireshark in Promiscuous Mode in the Capture Settings, you can capture most of the traffic on the LAN. DumpCap Dumpcap is a network traffic dump tool. It captures packet data from a live network and writes the packets to a file. Dumpcap\u2019s native capture file format is pcapng, which is also the format used by Wireshark. By default, Dumpcap uses the pcap library to capture traffic from the first available network interface and writes the received raw packet data, along with the packets\u2019 time stamps into a pcapng file. The capture filter syntax follows the rules of the pcap library. The Wireshark command-line utility called 'dumpcap.exe' can be used to capture LAN traffic over an extended period of time. Wireshark itself can also be used, but dumpcap does not significantly utilize the computer's memory while capturing for long periods. DaemonLogger Daemonlogger is a packet logging application designed specifically for use in Network and Systems Management (NSM) environments. The biggest benefit Daemonlogger provides is that, like Dumpcap, it is simple to use for capturing packets. In order to begin capturing, you need only to invoke the command and specify an interface. daemonlogger \u2013i eth1 This option, by default, will begin capturing packets and logging them to the current working directory. Packets will be collected until the capture file size reaches 2 GB, and then a new file will be created. This will continue indefinitely until the process is halted. NetSniff-NG Netsniff-NG is a high-performance packet capture utility While the utilities we\u2019ve discussed to this point rely on Libpcap for capture, Netsniff-NG utilizes zero-copy mechanisms to capture packets. This is done with the intent to support full packet capture over high throughput links. To begin capturing packets with Netsniff-NG, we have to specify an input and output. In most cases, the input will be a network interface, and the output will be a file or folder on disk. netsniff-ng \u2013i eth1 \u2013o data.pcap Netflow NetFlow is a feature that was introduced on Cisco routers around 1996 that provides the ability to collect IP network traffic as it enters or exits an interface. By analyzing the data provided by NetFlow, a network administrator can determine things such as the source and destination of traffic, class of service, and the causes of congestion. A typical flow monitoring setup (using NetFlow) consists of three main components:[1] Flow exporter: aggregates packets into flows and exports flow records towards one or more flow collectors. Flow collector: responsible for reception, storage and pre-processing of flow data received from a flow exporter. Analysis application: analyzes received flow data in the context of intrusion detection or traffic profiling, for example. Routers and switches that support NetFlow can collect IP traffic statistics on all interfaces where NetFlow is enabled, and later export those statistics as NetFlow records toward at least one NetFlow collector\u2014typically a server that does the actual traffic analysis. IDS A security solution that detects security-related events in your environment but does not block them. IDS sensors can be software and hardware-based used to collect and analyze the network traffic. These sensors are available in two varieties, network IDS and host IDS. A host IDS is a server-specific agent running on a server with a minimum of overhead to monitor the operating system. A network IDS can be embedded in a networking device, a standalone appliance, or a module monitoring the network traffic. Signature Based IDS The signature-based IDS monitors the network traffic or observes the system and sends an alarm if a known malicious event is happening. It does so by comparing the data flow against a database of known attack patterns These signatures explicitly define what traffic or activity should be considered as malicious. Signature-based detection has been the bread and butter of network-based defensive security for over a decade, partially because it is very similar to how malicious activity is detected at the host level with antivirus utilities The formula is fairly simple: an analyst observes a malicious activity, derives indicators from the activity and develops them into signatures, and then those signatures will alert whenever the activity occurs again. ex: SNORT & SURICATA Policy-Based IDS The policy-based IDSs (mainly host IDSs) trigger an alarm whenever a violation occurs against the configured policy. This configured policy is or should be a representation of the security policies. This type of IDS is flexible and can be customized to a company's network requirements because it knows exactly what is permitted and what is not. On the other hand, the signature-based systems rely on vendor specifics and default settings. Anomaly Based IDS The anomaly-based IDS looks for traffic that deviates from the normal, but the definition of what is a normal network traffic pattern is the tricky part Two types of anomaly-based IDS exist: statistical and nonstatistical anomaly detection Statistical anomaly detection learns the traffic patterns interactively over a period of time. In the nonstatistical approach, the IDS has a predefined configuration of the supposedly acceptable and valid traffic patterns. Host-Based IDS & Network-Based IDS A host IDS can be described as a distributed agent residing on each server of the network that needs protection. These distributed agents are tied very closely to the underlying operating system. Network IDSs, on the other hand, can be described as intelligent sniffing devices. Data (raw packets) is captured from the network by a network IDS, whereas host IDSs capture the data from the host on which they are installed. Honeypots The use of decoy machines to direct intruders' attention away from the machines under protection is a major technique to preclude intrusion attacks. Any device, system, directory, or file used as a decoy to lure attackers away from important assets and to collect intrusion or abusive behaviours is referred to as a honeypot. A honeypot may be implemented as a physical device or as an emulation system. The idea is to set up decoy machines in a LAN, or decoy directories/files in a file system and make them appear important, but with several exploitable loopholes, to lure attackers to attack these machines or directories/files, so that other machines, directories, and files can evade intruders' attentions. A decoy machine may be a host computer or a server computer. Likewise, we may also set up decoy routers or even decoy LANs. Chinks In The Armour (TCP/IP Security Issues) IP Spoofing In this type of attack, the attacker replaces the IP address of the sender, or in some rare cases the destination, with a different address. IP spoofing is normally used to exploit a target host. In other cases, it is used to start a denial-of-service (DoS) attack. In a DoS attack, an attacker modifies the IP packet to mislead the target host into accepting the original packet as a packet sourced at a trusted host. The attacker must know the IP address of the trusted host to modify the packet headers (source IP address) so that it appears that the packets are coming from that host. IP Spoofing Detection Techniques Direct TTL Probes In this technique we send a packet to a host of suspect spoofed IP that triggers reply and compares TTL with suspect packet; if the TTL in the reply is not the same as the packet being checked; it is a spoofed packet. This Technique is successful when the attacker is in a different subnet from the victim. IP Identification Number. Send a probe to the host of suspect spoofed traffic that triggers a reply and compares IP ID with suspect traffic. If IP IDs are not in the near value of packet being checked, suspect traffic is spoofed TCP Flow Control Method Attackers sending spoofed TCP packets will not receive the target\u2019s SYN-ACK packets. Attackers cannot, therefore, be responsive to change in the congestion window size When the receiver still receives traffic even after a windows size is exhausted, most probably the packets are spoofed. Covert Channel A covert or clandestine channel can be best described as a pipe or communication channel between two entities that can be exploited by a process or application transferring information in a manner that violates the system's security specifications. More specifically for TCP/IP, in some instances, covert channels are established, and data can be secretly passed between two end systems. Ex: ICMP resides at the Internet layer of the TCP/IP protocol suite and is implemented in all TCP/IP hosts. Based on the specifications of the ICMP Protocol, an ICMP Echo Request message should have an 8-byte header and a 56-byte payload. The ICMP Echo Request packet should not carry any data in the payload. However, these packets are often used to carry secret information. The ICMP packets are altered slightly to carry secret data in the payload. This makes the size of the packet larger, but no control exists in the protocol stack to defeat this behaviour. The alteration of ICMP packets allows intruders to program specialized client-server pairs. These small pieces of code export confidential information without alerting the network administrator. ICMP can be leveraged for more than data exfiltration. For eg. some C&C tools such as Loki used ICMP channel to establish encrypted interactive session back in 1996. Deep packet inspection has since come a long way. A lot of IDS/IPS detect ICMP tunnelling. Check for echo responses that do not contain the same payload as request Check for the volume of ICMP traffic especially for volumes beyond an acceptable threshold IP Fragmentation Attack The TCP/IP protocol suite, or more specifically IP, allows the fragmentation of packets.(this is a feature & not a bug) IP fragmentation offset is used to keep track of the different parts of a datagram. The information or content in this field is used at the destination to reassemble the datagrams All such fragments have the same Identification field value, and the fragmentation offset indicates the position of the current fragment in the context of the original packet. Many access routers and firewalls do not perform packet reassembly. In normal operation, IP fragments do not overlap, but attackers can create artificially fragmented packets to mislead the routers or firewalls. Usually, these packets are small and almost impractical for end systems because of data and computational overhead. A good example of an IP fragmentation attack is the Ping of Death attack. The Ping of Death attack sends fragments that, when reassembled at the end station, create a larger packet than the maximum permissible length. TCP Flags Data exchange using TCP does not happen until a three-way handshake has been completed. This handshake uses different flags to influence the way TCP segments are processed. There are 6 bits in the TCP header that are often called flags. Namely: 6 different flags are part of the TCP header: Urgent pointer field (URG), Acknowledgment field (ACK), Push function (PSH), Reset the connection (RST), Synchronize sequence numbers (SYN), and the sender is finished with this connection (FIN). Abuse of the normal operation or settings of these flags can be used by attackers to launch DoS attacks. This causes network servers or web servers to crash or hang. | SYN | FIN | PSH | RST | Validity| |------|------|-------|------|---------| | 1 |1 |0 |0 |Illegal Combination | 1 |1 |1 |0 |Illegal Combination | 1 |1 |0 |1 |Illegal Combination | 1 |1 |1 |1 |Illegal Combination The attacker's ultimate goal is to write special programs or pieces of code that can construct these illegal combinations resulting in an efficient DoS attack. SYN FLOOD The timers (or lack of certain timers) in 3 way handshake are often used and exploited by attackers to disable services or even to enter systems. After step 2 of the three-way handshake, no limit is set on the time to wait after receiving a SYN. The attacker initiates many connection requests to the webserver of Company XYZ (almost certainly with a spoofed IP address). The SYN+ACK packets (Step 2) sent by the web server back to the originating source IP address are not replied to. This leaves a TCP session half-open on the webserver. Multiple packets cause multiple TCP sessions to stay open. Based on the hardware limitations of the server, a limited number of TCP sessions can stay open, and as a result, the webserver refuses further connection establishments attempts from any host as soon as a certain limit is reached. These half-open connections need to be completed or timed out before new connections can be established. FIN Attack In normal operation, the sender sets the TCP FIN flag indicating that no more data will be transmitted and the connection can be closed down. This is a four-way handshake mechanism, with both sender and receiver expected to send an acknowledgement on a received FIN packet. During an attack that is trying to kill connections, a spoofed FIN packet is constructed. This packet also has the correct sequence number, so the packets are seen as valid by the targeted host. These sequence numbers are easy to predict. This process is referred to as TCP sequence number prediction, whereby the attacker either sniffs the current Sequence and Acknowledgment (SEQ/ACK) numbers of the connection or can algorithmically predict these numbers. Connection Hijacking An authorized user (Employee X) sends HTTP requests over a TCP session with the webserver. The web server accepts the packets from Employee X only when the packet has the correct SEQ/ACK numbers. As seen previously, these numbers are important for the webserver to distinguish between different sessions and to make sure it is still talking to Employee X. Imagine that the cracker starts sending packets to the web server spoofing the IP address of Employee X, using the correct SEQ/ACK combination. The web server accepts the packet and increments the ACK number. In the meantime, Employee X continues to send packets but with incorrect SEQ/ACK numbers. As a result of sending unsynchronized packets, all data from Employee X is discarded when received by the webserver. The attacker pretends to be Employee X using the correct numbers. This finally results in the cracker hijacking the connection, whereby Employee X is completely confused and the webserver replies assuming the cracker is sending correct synchronized data. STEPS: The attacker examines the traffic flows with a network monitor and notices traffic from Employee X to a web server. The web server returns or echoes data back to the origination station (Employee X). Employee X acknowledges the packet. The cracker launches a spoofed packet to the server. The web server responds to the cracker. The cracker starts verifying SEQ/ACK numbers to double-check success. At this time, the cracker takes over the session from Employee X, which results in a session hanging for Employee X. The cracker can start sending traffic to the webserver. The web server returns the requested data to confirm delivery with the correct ACK number. The cracker can continue to send data (keeping track of the correct SEQ/ACK numbers) until eventually setting the FIN flag to terminate the session. Buffer Overflow A buffer is a temporary data storage area used to store program code and data. When a program or process tries to store more data in a buffer than it was originally anticipated to hold, a buffer overflow occurs. Buffers are temporary storage locations in memory (memory or buffer sizes are often measured in bytes) that can store a fixed amount of data in bytes. When more data is retrieved than can be stored in a buffer location, the additional information must go into an adjacent buffer, resulting in overwriting the valid data held in them. Mechanism: Buffer overflow vulnerabilities exist in different types. But the overall goal for all buffer overflow attacks is to take over the control of a privileged program and, if possible, the host. The attacker has two tasks to achieve this goal. First, the dirty code needs to be available in the program's code address space. Second, the privileged program should jump to that particular part of the code, which ensures that the proper parameters are loaded into memory. The first task can be achieved in two ways: by injecting the code in the right address space or by using the existing code and modifying certain parameters slightly. The second task is a little more complex because the program's control flow needs to be modified to make the program jump to the dirty code. CounterMeasure: The most important approach is to have a concerted focus on writing correct code. A second method is to make the data buffers (memory locations) address space of the program code non-executable. This type of address space makes it impossible to execute code, which might be infiltrated in the program's buffers during an attack. More Spoofing Address Resolution Protocol Spoofing The Address Resolution Protocol (ARP) provides a mechanism to resolve, or map, a known IP address to a MAC sublayer address. Using ARP spoofing, the cracker can exploit this hardware address authentication mechanism by spoofing the hardware address of Host B. Basically, the attacker can convince any host or network device on the local network that the cracker's workstation is the host to be trusted. This is a common method used in a switched environment. ARP spoofing can be prevented with the implementation of static ARP tables in all the hosts and routers of your network. Alternatively, you can implement an ARP server that responds to ARP requests on behalf of the target host. DNS Spoofing DNS spoofing is the method whereby the hacker convinces the target machine that the system it wants to connect to is the machine of the cracker. The cracker modifies some records so that name entries of hosts correspond to the attacker's IP address. There have been instances in which the complete DNS server was compromised by an attack. To counter DNS spoofing, the reverse lookup detects these attacks. The reverse lookup is a mechanism to verify the IP address against a name. The IP address and name files are usually kept on different servers to make compromise much more difficult","title":"Network Security"},{"location":"level101/security/network_security/#part-ii-network-security","text":"","title":"Part II: Network Security"},{"location":"level101/security/network_security/#introduction","text":"TCP/IP is the dominant networking technology today. It is a five-layer architecture. These layers are, from top to bottom, the application layer, the transport layer (TCP), the network layer (IP), the data-link layer, and the physical layer. In addition to TCP/IP, there also are other networking technologies. For convenience, we use the OSI network model to represent non-TCP/IP network technologies. Different networks are interconnected using gateways. A gateway can be placed at any layer. The OSI model is a seven-layer architecture. The OSI architecture is similar to the TCP/IP architecture, except that the OSI model specifies two additional layers between the application layer and the transport layer in the TCP/IP architecture. These two layers are the presentation layer and the session layer. Figure 5.1 shows the relationship between the TCP/IP layers and the OSI layers. The application layer in TCP/IP corresponds to the application layer and the presentation layer in OSI. The transport layer in TCP/IP corresponds to the session layer and the transport layer in OSI. The remaining three layers in the TCP/IP architecture are one-to-one correspondent to the remaining three layers in the OSI model. Correspondence between layers of the TCP/IP architecture and the OSI model. Also shown are placements of cryptographic algorithms in network layers, where the dotted arrows indicate actual communications of cryptographic algorithms The functionalities of OSI layers are briefly described as follows: The application layer serves as an interface between applications and network programs. It supports application programs and end-user processing. Common application-layer programs include remote logins, file transfer, email, and Web browsing. The presentation layer is responsible for dealing with data that is formed differently. This protocol layer allows application-layer programs residing on different sides of a communication channel with different platforms to understand each other's data formats regardless of how they are presented. The session layer is responsible for creating, managing, and closing a communication connection. The transport layer is responsible for providing reliable connections, such as packet sequencing, traffic control, and congestion control. The network layer is responsible for routing device-independent data packets from the current hop to the next hop. The data-link layer is responsible for encapsulating device-independent data packets into device-dependent data frames. It has two sublayers: logical link control and media access control. The physical layer is responsible for transmitting device-dependent frames through some physical media. Starting from the application layer, data generated from an application program is passed down layer-by-layer to the physical layer. Data from the previous layer is enclosed in a new envelope at the current layer, where the data from the previous layer is also just an envelope containing the data from the layer before it. This is similar to enclosing a smaller envelope in a larger one. The envelope added at each layer contains sufficient information for handling the packet. Application-layer data are divided into blocks small enough to be encapsulated in an envelope at the next layer. Application data blocks are \u201cdressed up\u201d in the TCP/IP architecture according to the following basic steps. At the sending side, an application data block is encapsulated in a TCP packet when it is passed down to the TCP layer. In other words, a TCP packet consists of a header and a payload, where the header corresponds to the TCP envelope and the payload is the application data block. Likewise, the TCP packet will be encapsulated in an IP packet when it is passed down to the IP layer. An IP packet consists of a header and a payload, which is the TCP packet passed down from the TCP layer. The IP packet will be encapsulated in a device-dependent frame (e.g., an Ethernet frame) when it is passed down to the data-link layer. A frame has a header, and it may also have a trailer. For example, in addition to having a header, an Ethernet frame also has a 32-bit cyclic redundancy check (CRC) trailer. When it is passed down to the physical layer, a frame will be transformed into a sequence of media signals for transmission Flow Diagram of a Packet Generation At the destination side, the medium signals are converted by the physical layer into a frame, which is passed up to the data-link layer. The data-link layer passes the frame payload (i.e., the IP packet encapsulated in the frame) up to the IP layer. The IP layer passes the IP payload, namely, the TCP packet encapsulated in the IP packet, up to the TCP layer. The TCP layer passes the TCP payload, namely, the application data block, up to the application layer. When a packet arrives at a router, it only goes up to the IP layer, where certain fields in the IP header are modified (e.g., the value of TTL is decreased by 1). This modified packet is then passed back down layer-by-layer to the physical layer for further transmission.","title":"Introduction"},{"location":"level101/security/network_security/#public-key-infrastructure","text":"To deploy cryptographic algorithms in network applications, we need a way to distribute secret keys using open networks. Public-key cryptography is the best way to distribute these secret keys. To use public-key cryptography, we need to build a public-key infrastructure (PKI) to support and manage public-key certificates and certificate authority (CA) networks. In particular, PKIs are set up to perform the following functions: Determine the legitimacy of users before issuing public-key certificates to them. Issue public-key certificates upon user requests. Extend public-key certificates valid time upon user requests. Revoke public-key certificates upon users' requests or when the corresponding private keys are compromised. Store and manage public-key certificates. Prevent digital signature signers from denying their signatures. Support CA networks to allow different CAs to authenticate public-key certificates issued by other CAs. X.509: https://certificatedecoder.dev/?gclid=EAIaIQobChMI0M731O6G6gIVVSQrCh04bQaAEAAYASAAEgKRkPD_BwE","title":"Public Key Infrastructure"},{"location":"level101/security/network_security/#ipsec-a-security-protocol-at-the-network-layer","text":"IPsec is a major security protocol at the network layer IPsec provides a potent platform for constructing virtual private networks (VPN). VPNs are private networks overlayed on public networks. The purpose of deploying cryptographic algorithms at the network layer is to encrypt or authenticate IP packets (either just the payloads or the whole packets). IPsec also specifies how to exchange keys. Thus, IPsec consists of authentication protocols, encryption protocols, and key exchange protocols. They are referred to, respectively, as authentication header (AH), encapsulating security payload (ESP), and Internet key exchange (IKE).","title":"IPsec: A Security Protocol at the Network Layer"},{"location":"level101/security/network_security/#pgp-smime-email-security","text":"There are several security protocols at the application layer. The most used of these protocols are email security protocols namely PGP and S/MIME. SMTP (\u201cSimple Mail Transfer Protocol\u201d) is used for sending and delivering from a client to a server via port 25: it\u2019s the outgoing server. On the contrary, POP (\u201cPost Office Protocol\u201d) allows the users to pick up the message and download it into their inbox: it\u2019s the incoming server. The latest version of the Post Office Protocol is named POP3, and it\u2019s been used since 1996; it uses port 110 PGP PGP implements all major cryptographic algorithms, the ZIP compression algorithm, and the Base64 encoding algorithm. It can be used to authenticate a message, encrypt a message, or both. PGP follows the following general process: authentication, ZIP compression, encryption, and Base64 encoding. The Base64 encoding procedure makes the message ready for SMTP transmission GPG (GnuPG) GnuPG is another free encryption standard that companies may use that is based on OpenPGP. GnuPG serves as a replacement for Symantec\u2019s PGP. The main difference is the supported algorithms. However, GnuPG plays nice with PGP by design. Because GnuPG is open, some businesses would prefer the technical support and the user interface that comes with Symantec\u2019s PGP. It is important to note that there are some nuances between the compatibility of GnuPG and PGP, such as the compatibility between certain algorithms, but in most applications such as email, there are workarounds. One such algorithm is the IDEA Module which isn\u2019t included in GnuPG out of the box due to patent issues. S/MIME SMTP can only handle 7-bit ASCII text (You can use UTF-8 extensions to alleviate these limitations, ) messages. While POP can handle other content types besides 7-bit ASCII, POP may, under a common default setting, download all the messages stored in the mail server to the user's local computer. After that, if POP removes these messages from the mail server. This makes it difficult for the users to read their messages from multiple computers. The Multipurpose Internet Mail Extension protocol (MIME) was designed to support sending and receiving email messages in various formats, including nontext files generated by word processors, graphics files, sound files, and video clips. Moreover, MIME allows a single message to include mixed types of data in any combination of these formats. The Internet Mail Access Protocol (IMAP), operated on TCP port 143(only for non-encrypted), stores (Configurable on both server & client just like PoP) incoming email messages in the mail server until the user deletes them deliberately. This allows the users to access their mailbox from multiple machines and download messages to a local machine without deleting it from the mailbox in the mail server. SSL/TLS SSL uses a PKI to decide if a server\u2019s public key is trustworthy by requiring servers to use a security certificate signed by a trusted CA. When Netscape Navigator 1.0 was released, it trusted a single CA operated by the RSA Data Security corporation. The server\u2019s public RSA keys were used to be stored in the security certificate, which can then be used by the browser to establish a secure communication channel. The security certificates we use today still rely on the same standard (named X.509) that Netscape Navigator 1.0 used back then. Netscape intended to train users(though this didn\u2019t work out later) to differentiate secure communications from insecure ones, so they put a lock icon next to the address bar. When the lock is open, the communication is insecure. A closed lock means communication has been secured with SSL, which required the server to provide a signed certificate. You\u2019re obviously familiar with this icon as it\u2019s been in every browser ever since. The engineers at Netscape truly created a standard for secure internet communications. A year after releasing SSL 2.0, Netscape fixed several security issues and released SSL 3.0, a protocol that, albeit being officially deprecated since June 2015, remains in use in certain parts of the world more than 20 years after its introduction. To standardize SSL, the Internet Engineering Task Force (IETF) created a slightly modified SSL 3.0 and, in 1999, unveiled it as Transport Layer Security (TLS) 1.0. The name change between SSL and TLS continues to confuse people today. Officially, TLS is the new SSL, but in practice, people use SSL and TLS interchangeably to talk about any version of the protocol. Must See: https://tls.ulfheim.net/ https://davidwong.fr/tls13/","title":"PGP & S/MIME : Email Security"},{"location":"level101/security/network_security/#network-perimeter-security","text":"Let us see how we keep a check on the perimeter i.e the edges, the first layer of protection","title":"Network Perimeter Security"},{"location":"level101/security/network_security/#general-firewall-framework","text":"Firewalls are needed because encryption algorithms cannot effectively stop malicious packets from getting into an edge network. This is because IP packets, regardless of whether they are encrypted, can always be forwarded into an edge network. Firewalls that were developed in the 1990s are important instruments to help restrict network access. A firewall may be a hardware device, a software package, or a combination of both. Packets flowing into the internal network from the outside should be evaluated before they are allowed to enter. One of the critical elements of a firewall is its ability to examine packets without imposing a negative impact on communication speed while providing security protections for the internal network. The packet inspection that is carried out by firewalls can be done using several different methods. Based on the particular method used by the firewall, it can be characterized as either a packet filter, circuit gateway, application gateway, or dynamic packet filter.","title":"General Firewall Framework"},{"location":"level101/security/network_security/#packet-filters","text":"It inspects ingress packets coming to an internal network from outside and inspects egress packets going outside from an internal network Packing filtering only inspects IP headers and TCP headers, not the payloads generated at the application layer A packet-filtering firewall uses a set of rules to determine whether a packet should be allowed or denied to pass through. 2 types: Stateless It treats each packet as an independent object, and it does not keep track of any previously processed packets. In other words, stateless filtering inspects a packet when it arrives and makes a decision without leaving any record of the packet being inspected. Stateful Stateful filtering, also referred to as connection-state filtering, keeps track of connections between an internal host and an external host. A connection state (or state, for short) indicates whether it is a TCP connection or a UDP connection and whether the connection is established.","title":"Packet Filters"},{"location":"level101/security/network_security/#circuit-gateways","text":"Circuit gateways, also referred to as circuit-level gateways, are typically operated at the transportation layer They evaluate the information of the IP addresses and the port numbers contained in TCP (or UDP) headers and use it to determine whether to allow or to disallow an internal host and an external host to establish a connection. It is common practice to combine packet filters and circuit gateways to form a dynamic packet filter (DPF).","title":"Circuit Gateways"},{"location":"level101/security/network_security/#application-gatewaysalg","text":"Aka PROXY Servers An Application Level Gateway (ALG) acts as a proxy for internal hosts, processing service requests from external clients. An ALG performs deep inspections on each IP packet (ingress or egress). In particular, an ALG inspects application program formats contained in the packet (e.g., MIME format or SQL format) and examines whether its payload is permitted. Thus, an ALG may be able to detect a computer virus contained in the payload. Because an ALG inspects packet payloads, it may be able to detect malicious code and quarantine suspicious packets, in addition to blocking packets with suspicious IP addresses and TCP ports. On the other hand, an ALG also incurs substantial computation and space overheads.","title":"Application Gateways(ALG)"},{"location":"level101/security/network_security/#trusted-systems-bastion-hosts","text":"A Trusted Operating System (TOS) is an operating system that meets a particular set of security requirements. Whether an operating system can be trusted or not depends on several elements. For example, for an operating system on a particular computer to be certified trusted, one needs to validate that, among other things, the following four requirements are satisfied: Its system design contains no defects; Its system software contains no loopholes; Its system is configured properly; and Its system management is appropriate. Bastion Hosts Bastion hosts are computers with strong defence mechanisms. They often serve as host computers for implementing application gateways, circuit gateways, and other types of firewalls. A bastion host is operated on a trusted operating system that must not contain unnecessary functionalities or programs. This measure helps to reduce error probabilities and makes it easier to conduct security checks. Only those network application programs that are necessary, for example, SSH, DNS, SMTP, and authentication programs, are installed on a bastion host. Bastion hosts are also primarily used as controlled ingress points so that the security monitoring can focus more narrowly on actions happening at a single point closely.","title":"Trusted Systems & Bastion Hosts"},{"location":"level101/security/network_security/#common-techniques-scannings-packet-capturing","text":"","title":"Common Techniques & Scannings, Packet Capturing"},{"location":"level101/security/network_security/#scanning-ports-with-nmap","text":"Nmap (\"Network Mapper\") is a free and open-source (license) utility for network discovery and security auditing. Many systems and network administrators also find it useful for tasks such as network inventory, managing service upgrade schedules, and monitoring host or service uptime. The best thing about Nmap is it\u2019s free and open-source and is very flexible and versatile Nmap is often used to determine alive hosts in a network, open ports on those hosts, services running on those open ports, and version identification of that service on that port. More at http://scanme.nmap.org/ nmap [scan type] [options] [target specification] Nmap uses 6 different port states: Open \u2014 An open port is one that is actively accepting TCP, UDP or SCTP connections. Open ports are what interests us the most because they are the ones that are vulnerable to attacks. Open ports also show the available services on a network. Closed \u2014 A port that receives and responds to Nmap probe packets but there is no application listening on that port. Useful for identifying that the host exists and for OS detection. Filtered \u2014 Nmap can\u2019t determine whether the port is open because packet filtering prevents its probes from reaching the port. Filtering could come from firewalls or router rules. Often little information is given from filtered ports during scans as the filters can drop the probes without responding or respond with useless error messages e.g. destination unreachable. Unfiltered \u2014 Port is accessible but Nmap doesn\u2019t know if it is open or closed. Only used in ACK scan which is used to map firewall rulesets. Other scan types can be used to identify whether the port is open. Open/filtered \u2014 Nmap is unable to determine between open and filtered. This happens when an open port gives no response. No response could mean that the probe was dropped by a packet filter or any response is blocked. Closed/filtered \u2014 Nmap is unable to determine whether a port is closed or filtered. Only used in the IP ID idle scan.","title":"Scanning Ports with Nmap"},{"location":"level101/security/network_security/#types-of-nmap-scan","text":"TCP Connect TCP Connect scan completes the 3-way handshake. If a port is open, the operating system completes the TCP three-way handshake and the port scanner immediately closes the connection to avoid DOS. This is \u201cnoisy\u201d because the services can log the sender IP address and might trigger Intrusion Detection Systems. UDP Scan This scan checks to see if any UDP ports are listening. Since UDP does not respond with a positive acknowledgement like TCP and only responds to an incoming UDP packet when the port is closed, SYN Scan SYN scan is another form of TCP scanning. This scan type is also known as \u201chalf-open scanning\u201d because it never actually opens a full TCP connection. The port scanner generates a SYN packet. If the target port is open, it will respond with an SYN-ACK packet. The scanner host responds with an RST packet, closing the connection before the handshake is completed. If the port is closed but unfiltered, the target will instantly respond with an RST packet. SYN scan has the advantage that the individual services never actually receive a connection. FIN Scan This is a stealthy scan, like the SYN scan, but sends a TCP FIN packet instead. ACK Scan Ack scanning determines whether the port is filtered or not. Null Scan Another very stealthy scan that sets all the TCP header flags to off or null. This is not normally a valid packet and some hosts will not know what to do with this. XMAS Scan Similar to the NULL scan except for all the flags in the TCP header is set to on RPC Scan This special type of scan looks for machine answering to RPC (Remote Procedure Call) services IDLE Scan It is a super stealthy method whereby the scan packets are bounced off an external host. You don\u2019t need to have control over the other host but it does have to set up and meet certain requirements. You must input the IP address of our \u201czombie\u201d host and what port number to use. It is one of the more controversial options in Nmap since it only has a use for malicious attacks. Scan Techniques A couple of scan techniques which can be used to gain more information about a system and its ports. You can read more at https://medium.com/infosec-adventures/nmap-cheatsheet-a423fcdda0ca","title":"Types of Nmap Scan:"},{"location":"level101/security/network_security/#openvas","text":"OpenVAS is a full-featured vulnerability scanner. OpenVAS is a framework of services and tools that provides a comprehensive and powerful vulnerability scanning and management package OpenVAS, which is an open-source program, began as a fork of the once-more-popular scanning program, Nessus. OpenVAS is made up of three main parts. These are: a regularly updated feed of Network Vulnerability Tests (NVTs); a scanner, which runs the NVTs; and an SQLite 3 database for storing both your test configurations and the NVTs\u2019 results and configurations. https://www.greenbone.net/en/install_use_gce/","title":"OpenVAS"},{"location":"level101/security/network_security/#wireshark","text":"Wireshark is a protocol analyzer. This means Wireshark is designed to decode not only packet bits and bytes but also the relations between packets and protocols. Wireshark understands protocol sequences. A simple demo of Wireshark Capture only udp packets: Capture filter = \u201cudp\u201d Capture only tcp packets Capture filter = \u201ctcp\u201d TCP/IP 3 way Handshake Filter by IP address: displays all traffic from IP, be it source or destination ip.addr == 192.168.1.1 Filter by source address: display traffic only from IP source ip.src == 192.168.0.1 Filter by destination: display traffic only form IP destination ip.dst == 192.168.0.1 Filter by IP subnet: display traffic from subnet, be it source or destination ip.addr = 192.168.0.1/24 Filter by protocol: filter traffic by protocol name dns http ftp arp ssh telnet icmp Exclude IP address: remove traffic from and to IP address !ip.addr ==192.168.0.1 Display traffic between two specific subnet ip.addr == 192.168.0.1/24 and ip.addr == 192.168.1.1/24 Display traffic between two specific workstations ip.addr == 192.168.0.1 and ip.addr == 192.168.0.2 Filter by MAC eth.addr = 00:50:7f:c5:b6:78 Filter TCP port tcp.port == 80 Filter TCP port source tcp.srcport == 80 Filter TCP port destination tcp.dstport == 80 Find user agents http.user_agent contains Firefox !http.user_agent contains || !http.user_agent contains Chrome Filter broadcast traffic !(arp or icmp or dns) Filter IP address and port tcp.port == 80 && ip.addr == 192.168.0.1 Filter all http get requests http.request Filter all http get requests and responses http.request or http.response Filter three way handshake tcp.flags.syn==1 or (tcp.seq==1 and tcp.ack==1 and tcp.len==0 and tcp.analysis.initial_rtt) Find files by type frame contains \u201c(attachment|tar|exe|zip|pdf)\u201d Find traffic based on keyword tcp contains facebook frame contains facebook Detecting SYN Floods tcp.flags.syn == 1 and tcp.flags.ack == 0 Wireshark Promiscuous Mode - By default, Wireshark only captures packets going to and from the computer where it runs. By checking the box to run Wireshark in Promiscuous Mode in the Capture Settings, you can capture most of the traffic on the LAN.","title":"WireShark"},{"location":"level101/security/network_security/#dumpcap","text":"Dumpcap is a network traffic dump tool. It captures packet data from a live network and writes the packets to a file. Dumpcap\u2019s native capture file format is pcapng, which is also the format used by Wireshark. By default, Dumpcap uses the pcap library to capture traffic from the first available network interface and writes the received raw packet data, along with the packets\u2019 time stamps into a pcapng file. The capture filter syntax follows the rules of the pcap library. The Wireshark command-line utility called 'dumpcap.exe' can be used to capture LAN traffic over an extended period of time. Wireshark itself can also be used, but dumpcap does not significantly utilize the computer's memory while capturing for long periods.","title":"DumpCap"},{"location":"level101/security/network_security/#daemonlogger","text":"Daemonlogger is a packet logging application designed specifically for use in Network and Systems Management (NSM) environments. The biggest benefit Daemonlogger provides is that, like Dumpcap, it is simple to use for capturing packets. In order to begin capturing, you need only to invoke the command and specify an interface. daemonlogger \u2013i eth1 This option, by default, will begin capturing packets and logging them to the current working directory. Packets will be collected until the capture file size reaches 2 GB, and then a new file will be created. This will continue indefinitely until the process is halted.","title":"DaemonLogger"},{"location":"level101/security/network_security/#netsniff-ng","text":"Netsniff-NG is a high-performance packet capture utility While the utilities we\u2019ve discussed to this point rely on Libpcap for capture, Netsniff-NG utilizes zero-copy mechanisms to capture packets. This is done with the intent to support full packet capture over high throughput links. To begin capturing packets with Netsniff-NG, we have to specify an input and output. In most cases, the input will be a network interface, and the output will be a file or folder on disk. netsniff-ng \u2013i eth1 \u2013o data.pcap","title":"NetSniff-NG"},{"location":"level101/security/network_security/#netflow","text":"NetFlow is a feature that was introduced on Cisco routers around 1996 that provides the ability to collect IP network traffic as it enters or exits an interface. By analyzing the data provided by NetFlow, a network administrator can determine things such as the source and destination of traffic, class of service, and the causes of congestion. A typical flow monitoring setup (using NetFlow) consists of three main components:[1] Flow exporter: aggregates packets into flows and exports flow records towards one or more flow collectors. Flow collector: responsible for reception, storage and pre-processing of flow data received from a flow exporter. Analysis application: analyzes received flow data in the context of intrusion detection or traffic profiling, for example. Routers and switches that support NetFlow can collect IP traffic statistics on all interfaces where NetFlow is enabled, and later export those statistics as NetFlow records toward at least one NetFlow collector\u2014typically a server that does the actual traffic analysis.","title":"Netflow"},{"location":"level101/security/network_security/#ids","text":"A security solution that detects security-related events in your environment but does not block them. IDS sensors can be software and hardware-based used to collect and analyze the network traffic. These sensors are available in two varieties, network IDS and host IDS. A host IDS is a server-specific agent running on a server with a minimum of overhead to monitor the operating system. A network IDS can be embedded in a networking device, a standalone appliance, or a module monitoring the network traffic. Signature Based IDS The signature-based IDS monitors the network traffic or observes the system and sends an alarm if a known malicious event is happening. It does so by comparing the data flow against a database of known attack patterns These signatures explicitly define what traffic or activity should be considered as malicious. Signature-based detection has been the bread and butter of network-based defensive security for over a decade, partially because it is very similar to how malicious activity is detected at the host level with antivirus utilities The formula is fairly simple: an analyst observes a malicious activity, derives indicators from the activity and develops them into signatures, and then those signatures will alert whenever the activity occurs again. ex: SNORT & SURICATA Policy-Based IDS The policy-based IDSs (mainly host IDSs) trigger an alarm whenever a violation occurs against the configured policy. This configured policy is or should be a representation of the security policies. This type of IDS is flexible and can be customized to a company's network requirements because it knows exactly what is permitted and what is not. On the other hand, the signature-based systems rely on vendor specifics and default settings. Anomaly Based IDS The anomaly-based IDS looks for traffic that deviates from the normal, but the definition of what is a normal network traffic pattern is the tricky part Two types of anomaly-based IDS exist: statistical and nonstatistical anomaly detection Statistical anomaly detection learns the traffic patterns interactively over a period of time. In the nonstatistical approach, the IDS has a predefined configuration of the supposedly acceptable and valid traffic patterns. Host-Based IDS & Network-Based IDS A host IDS can be described as a distributed agent residing on each server of the network that needs protection. These distributed agents are tied very closely to the underlying operating system. Network IDSs, on the other hand, can be described as intelligent sniffing devices. Data (raw packets) is captured from the network by a network IDS, whereas host IDSs capture the data from the host on which they are installed. Honeypots The use of decoy machines to direct intruders' attention away from the machines under protection is a major technique to preclude intrusion attacks. Any device, system, directory, or file used as a decoy to lure attackers away from important assets and to collect intrusion or abusive behaviours is referred to as a honeypot. A honeypot may be implemented as a physical device or as an emulation system. The idea is to set up decoy machines in a LAN, or decoy directories/files in a file system and make them appear important, but with several exploitable loopholes, to lure attackers to attack these machines or directories/files, so that other machines, directories, and files can evade intruders' attentions. A decoy machine may be a host computer or a server computer. Likewise, we may also set up decoy routers or even decoy LANs.","title":"IDS"},{"location":"level101/security/network_security/#chinks-in-the-armour-tcpip-security-issues","text":"","title":"Chinks In The Armour (TCP/IP Security Issues)"},{"location":"level101/security/network_security/#ip-spoofing","text":"In this type of attack, the attacker replaces the IP address of the sender, or in some rare cases the destination, with a different address. IP spoofing is normally used to exploit a target host. In other cases, it is used to start a denial-of-service (DoS) attack. In a DoS attack, an attacker modifies the IP packet to mislead the target host into accepting the original packet as a packet sourced at a trusted host. The attacker must know the IP address of the trusted host to modify the packet headers (source IP address) so that it appears that the packets are coming from that host. IP Spoofing Detection Techniques Direct TTL Probes In this technique we send a packet to a host of suspect spoofed IP that triggers reply and compares TTL with suspect packet; if the TTL in the reply is not the same as the packet being checked; it is a spoofed packet. This Technique is successful when the attacker is in a different subnet from the victim. IP Identification Number. Send a probe to the host of suspect spoofed traffic that triggers a reply and compares IP ID with suspect traffic. If IP IDs are not in the near value of packet being checked, suspect traffic is spoofed TCP Flow Control Method Attackers sending spoofed TCP packets will not receive the target\u2019s SYN-ACK packets. Attackers cannot, therefore, be responsive to change in the congestion window size When the receiver still receives traffic even after a windows size is exhausted, most probably the packets are spoofed.","title":"IP Spoofing"},{"location":"level101/security/network_security/#covert-channel","text":"A covert or clandestine channel can be best described as a pipe or communication channel between two entities that can be exploited by a process or application transferring information in a manner that violates the system's security specifications. More specifically for TCP/IP, in some instances, covert channels are established, and data can be secretly passed between two end systems. Ex: ICMP resides at the Internet layer of the TCP/IP protocol suite and is implemented in all TCP/IP hosts. Based on the specifications of the ICMP Protocol, an ICMP Echo Request message should have an 8-byte header and a 56-byte payload. The ICMP Echo Request packet should not carry any data in the payload. However, these packets are often used to carry secret information. The ICMP packets are altered slightly to carry secret data in the payload. This makes the size of the packet larger, but no control exists in the protocol stack to defeat this behaviour. The alteration of ICMP packets allows intruders to program specialized client-server pairs. These small pieces of code export confidential information without alerting the network administrator. ICMP can be leveraged for more than data exfiltration. For eg. some C&C tools such as Loki used ICMP channel to establish encrypted interactive session back in 1996. Deep packet inspection has since come a long way. A lot of IDS/IPS detect ICMP tunnelling. Check for echo responses that do not contain the same payload as request Check for the volume of ICMP traffic especially for volumes beyond an acceptable threshold","title":"Covert Channel"},{"location":"level101/security/network_security/#ip-fragmentation-attack","text":"The TCP/IP protocol suite, or more specifically IP, allows the fragmentation of packets.(this is a feature & not a bug) IP fragmentation offset is used to keep track of the different parts of a datagram. The information or content in this field is used at the destination to reassemble the datagrams All such fragments have the same Identification field value, and the fragmentation offset indicates the position of the current fragment in the context of the original packet. Many access routers and firewalls do not perform packet reassembly. In normal operation, IP fragments do not overlap, but attackers can create artificially fragmented packets to mislead the routers or firewalls. Usually, these packets are small and almost impractical for end systems because of data and computational overhead. A good example of an IP fragmentation attack is the Ping of Death attack. The Ping of Death attack sends fragments that, when reassembled at the end station, create a larger packet than the maximum permissible length. TCP Flags Data exchange using TCP does not happen until a three-way handshake has been completed. This handshake uses different flags to influence the way TCP segments are processed. There are 6 bits in the TCP header that are often called flags. Namely: 6 different flags are part of the TCP header: Urgent pointer field (URG), Acknowledgment field (ACK), Push function (PSH), Reset the connection (RST), Synchronize sequence numbers (SYN), and the sender is finished with this connection (FIN). Abuse of the normal operation or settings of these flags can be used by attackers to launch DoS attacks. This causes network servers or web servers to crash or hang. | SYN | FIN | PSH | RST | Validity| |------|------|-------|------|---------| | 1 |1 |0 |0 |Illegal Combination | 1 |1 |1 |0 |Illegal Combination | 1 |1 |0 |1 |Illegal Combination | 1 |1 |1 |1 |Illegal Combination The attacker's ultimate goal is to write special programs or pieces of code that can construct these illegal combinations resulting in an efficient DoS attack. SYN FLOOD The timers (or lack of certain timers) in 3 way handshake are often used and exploited by attackers to disable services or even to enter systems. After step 2 of the three-way handshake, no limit is set on the time to wait after receiving a SYN. The attacker initiates many connection requests to the webserver of Company XYZ (almost certainly with a spoofed IP address). The SYN+ACK packets (Step 2) sent by the web server back to the originating source IP address are not replied to. This leaves a TCP session half-open on the webserver. Multiple packets cause multiple TCP sessions to stay open. Based on the hardware limitations of the server, a limited number of TCP sessions can stay open, and as a result, the webserver refuses further connection establishments attempts from any host as soon as a certain limit is reached. These half-open connections need to be completed or timed out before new connections can be established. FIN Attack In normal operation, the sender sets the TCP FIN flag indicating that no more data will be transmitted and the connection can be closed down. This is a four-way handshake mechanism, with both sender and receiver expected to send an acknowledgement on a received FIN packet. During an attack that is trying to kill connections, a spoofed FIN packet is constructed. This packet also has the correct sequence number, so the packets are seen as valid by the targeted host. These sequence numbers are easy to predict. This process is referred to as TCP sequence number prediction, whereby the attacker either sniffs the current Sequence and Acknowledgment (SEQ/ACK) numbers of the connection or can algorithmically predict these numbers.","title":"IP Fragmentation Attack"},{"location":"level101/security/network_security/#connection-hijacking","text":"An authorized user (Employee X) sends HTTP requests over a TCP session with the webserver. The web server accepts the packets from Employee X only when the packet has the correct SEQ/ACK numbers. As seen previously, these numbers are important for the webserver to distinguish between different sessions and to make sure it is still talking to Employee X. Imagine that the cracker starts sending packets to the web server spoofing the IP address of Employee X, using the correct SEQ/ACK combination. The web server accepts the packet and increments the ACK number. In the meantime, Employee X continues to send packets but with incorrect SEQ/ACK numbers. As a result of sending unsynchronized packets, all data from Employee X is discarded when received by the webserver. The attacker pretends to be Employee X using the correct numbers. This finally results in the cracker hijacking the connection, whereby Employee X is completely confused and the webserver replies assuming the cracker is sending correct synchronized data. STEPS: The attacker examines the traffic flows with a network monitor and notices traffic from Employee X to a web server. The web server returns or echoes data back to the origination station (Employee X). Employee X acknowledges the packet. The cracker launches a spoofed packet to the server. The web server responds to the cracker. The cracker starts verifying SEQ/ACK numbers to double-check success. At this time, the cracker takes over the session from Employee X, which results in a session hanging for Employee X. The cracker can start sending traffic to the webserver. The web server returns the requested data to confirm delivery with the correct ACK number. The cracker can continue to send data (keeping track of the correct SEQ/ACK numbers) until eventually setting the FIN flag to terminate the session.","title":"Connection Hijacking"},{"location":"level101/security/network_security/#buffer-overflow","text":"A buffer is a temporary data storage area used to store program code and data. When a program or process tries to store more data in a buffer than it was originally anticipated to hold, a buffer overflow occurs. Buffers are temporary storage locations in memory (memory or buffer sizes are often measured in bytes) that can store a fixed amount of data in bytes. When more data is retrieved than can be stored in a buffer location, the additional information must go into an adjacent buffer, resulting in overwriting the valid data held in them. Mechanism: Buffer overflow vulnerabilities exist in different types. But the overall goal for all buffer overflow attacks is to take over the control of a privileged program and, if possible, the host. The attacker has two tasks to achieve this goal. First, the dirty code needs to be available in the program's code address space. Second, the privileged program should jump to that particular part of the code, which ensures that the proper parameters are loaded into memory. The first task can be achieved in two ways: by injecting the code in the right address space or by using the existing code and modifying certain parameters slightly. The second task is a little more complex because the program's control flow needs to be modified to make the program jump to the dirty code. CounterMeasure: The most important approach is to have a concerted focus on writing correct code. A second method is to make the data buffers (memory locations) address space of the program code non-executable. This type of address space makes it impossible to execute code, which might be infiltrated in the program's buffers during an attack.","title":"Buffer Overflow"},{"location":"level101/security/network_security/#more-spoofing","text":"Address Resolution Protocol Spoofing The Address Resolution Protocol (ARP) provides a mechanism to resolve, or map, a known IP address to a MAC sublayer address. Using ARP spoofing, the cracker can exploit this hardware address authentication mechanism by spoofing the hardware address of Host B. Basically, the attacker can convince any host or network device on the local network that the cracker's workstation is the host to be trusted. This is a common method used in a switched environment. ARP spoofing can be prevented with the implementation of static ARP tables in all the hosts and routers of your network. Alternatively, you can implement an ARP server that responds to ARP requests on behalf of the target host. DNS Spoofing DNS spoofing is the method whereby the hacker convinces the target machine that the system it wants to connect to is the machine of the cracker. The cracker modifies some records so that name entries of hosts correspond to the attacker's IP address. There have been instances in which the complete DNS server was compromised by an attack. To counter DNS spoofing, the reverse lookup detects these attacks. The reverse lookup is a mechanism to verify the IP address against a name. The IP address and name files are usually kept on different servers to make compromise much more difficult","title":"More Spoofing"},{"location":"level101/security/threats_attacks_defences/","text":"Part III: Threats, Attacks & Defense DNS Protection Cache Poisoning Attack Since DNS responses are cached, a quick response can be provided for repeated translations. DNS negative queries are also cached, e.g., misspelt words, and all cached data periodically times out. Cache poisoning is an issue in what is known as pharming. This term is used to describe a hacker\u2019s attack in which a website\u2019s traffic is redirected to a bogus website by forging the DNS mapping. In this case, an attacker attempts to insert a fake address record for an Internet domain into the DNS. If the server accepts the fake record, the cache is poisoned and subsequent requests for the address of the domain are answered with the address of a server controlled by the attacker. As long as the fake entry is cached by the server, browsers or e-mail servers will automatically go to the address provided by the compromised DNS server. the typical time to live (TTL) for cached entries is a couple of hours, thereby permitting ample time for numerous users to be affected by the attack. DNSSEC (Security Extension) The long-term solution to these DNS problems is authentication. If a resolver cannot distinguish between valid and invalid data in a response, then add source authentication to verify that the data received in response is equal to the data entered by the zone administrator DNS Security Extensions (DNSSEC) protects against data spoofing and corruption and provides mechanisms to authenticate servers and requests, as well as mechanisms to establish authenticity and integrity. When authenticating DNS responses, each DNS zone signs its data using a private key. It is recommended that this signing be done offline and in advance. The query for a particular record returns the requested resource record set (RRset) and signature (RRSIG) of the requested resource record set. The resolver then authenticates the response using a public key, which is pre-configured or learned via a sequence of key records in the DNS hierarchy. The goals of DNSSEC are to provide authentication and integrity for DNS responses without confidentiality or DDoS protection. BGP BGP stands for border gateway protocol. It is a routing protocol that exchanges routing information among multiple Autonomous Systems (AS) An Autonomous System is a collection of routers or networks with the same network policy usually under single administrative control. BGP tells routers which hop to use in order to reach the destination network. BGP is used for both communicating information among routers in an AS (interior) and between multiple ASes (exterior). How BGP Works BGP is responsible for finding a path to a destination router & the path it chooses should be the shortest and most reliable one. This decision is done through a protocol known as Link state. With the link-state protocol, each router broadcasts to all other routers in the network the state of its links and IP subnets. Each router then receives information from the other routers and constructs a complete topology view of the entire network. The next-hop routing table is based on this topology view. The link-state protocol uses a famous algorithm in the field of computer science, Dijkstra\u2019s shortest path algorithm: We start from our router considering the path cost to all our direct neighbours. The shortest path is then taken We then re-look at all our neighbours that we can reach and update our link state table with the cost information. We then continue taking the shortest path until every router has been visited. BGP Vulnerabilities By corrupting the BGP routing table we are able to influence the direction traffic flows on the internet! This action is known as BGP hijacking. Injecting bogus route advertising information into the BGP-distributed routing database by malicious sources, accidentally or routers can disrupt Internet backbone operations. Blackholing traffic: Blackhole route is a network route, i.e., routing table entry, that goes nowhere and packets matching the route prefix are dropped or ignored. Blackhole routes can only be detected by monitoring the lost traffic. Blackhole routes are the best defence against many common viral attacks where the traffic is dropped from infected machines to/from command & control hosts. Infamous BGP Injection attack on Youtube Ex: In 2008, Pakistan decided to block YouTube by creating a BGP route that led into a black hole. Instead, this routing information got transmitted to a hong kong ISP and from there accidentally got propagated to the rest of the world meaning millions were routed through to this black hole and therefore unable to access YouTube. Potentially, the greatest risk to BGP occurs in a denial of service attack in which a router is flooded with more packets than it can handle. Network overload and router resource exhaustion happen when the network begins carrying an excessive number of BGP messages, overloading the router control processors, memory, routing table and reducing the bandwidth available for data traffic. Refer: https://medium.com/bugbountywriteup/bgp-the-weak-link-in-the-internet-what-is-bgp-and-how-do-hackers-exploit-it-d899a68ba5bb Router flapping is another type of attack. Route flapping refers to repetitive changes to the BGP routing table, often several times a minute. Withdrawing and re-advertising at a high-rate can cause a serious problem for routers since they propagate the announcements of routes. If these route flaps happen fast enough, e.g., 30 to 50 times per second, the router becomes overloaded, which eventually prevents convergence on valid routes. The potential impact for Internet users is a slowdown in message delivery, and in some cases, packets may not be delivered at all. BGP Security Border Gateway Protocol Security recommends the use of BGP peer authentication since it is one of the strongest mechanisms for preventing malicious activity. The authentication mechanisms are Internet Protocol Security (IPsec) or BGP MD5. Another method, known as prefix limits, can be used to avoid filling router tables. In this approach, routers should be configured to disable or terminate a BGP peering session, and issue warning messages to administrators when a neighbour sends in excess of a preset number of prefixes. IETF is currently working on improving this space Web-Based Attacks HTTP Response Splitting Attacks HTTP response splitting attack may happen where the server script embeds user data in HTTP response headers without appropriate sanitation. This typically happens when the script embeds user data in the redirection URL of a redirection response (HTTP status code 3xx), or when the script embeds user data in a cookie value or name when the response sets a cookie. HTTP response splitting attacks can be used to perform web cache poisoning and cross-site scripting attacks. HTTP response splitting is the attacker\u2019s ability to send a single HTTP request that forces the webserver to form an output stream, which is then interpreted by the target as two HTTP responses instead of one response. Cross-Site Request Forgery (CSRF or XSRF) A Cross-Site Request Forgery attack tricks the victim\u2019s browser into issuing a command to a vulnerable web application. Vulnerability is caused by browsers automatically including user authentication data, session ID, IP address, Windows domain credentials, etc. with each request. Attackers typically use CSRF to initiate transactions such as transfer funds, login/logout user, close account, access sensitive data, and change account details. The vulnerability is caused by web browsers that automatically include credentials with each request, even for requests caused by a form, script, or image on another site. CSRF can also be dynamically constructed as part of a payload for a cross-site scripting attack All sites relying on automatic credentials are vulnerable. Popular browsers cannot prevent cross-site request forgery. Logging out of high-value sites as soon as possible can mitigate CSRF risk. It is recommended that a high-value website must require a client to manually provide authentication data in the same HTTP request used to perform any operation with security implications. Limiting the lifetime of session cookies can also reduce the chance of being used by other malicious sites. OWASP recommends website developers include a required security token in HTTP requests associated with sensitive business functions in order to mitigate CSRF attacks Cross-Site Scripting (XSS) Attacks Cross-Site Scripting occurs when dynamically generated web pages display user input, such as login information, that is not properly validated, allowing an attacker to embed malicious scripts into the generated page and then execute the script on the machine of any user that views the site. If successful, Cross-Site Scripting vulnerabilities can be exploited to manipulate or steal cookies, create requests that can be mistaken for those of a valid user, compromise confidential information, or execute malicious code on end-user systems. Cross-Site Scripting (XSS or CSS) attacks involve the execution of malicious scripts on the victim\u2019s browser. The victim is simply a user\u2019s host and not the server. XSS results from a failure to validate user input by a web-based application. Document Object Model (DOM) XSS Attacks The Document Object Model (DOM) based XSS does not require the webserver to receive the XSS payload for a successful attack. The attacker abuses the runtime by embedding their data on the client-side. An attacker can force the client (browser) to render the page with parts of the DOM controlled by the attacker. When the page is rendered and the data is processed by the page, typically by a client-side HTML-embedded script such as JavaScript, the page\u2019s code may insecurely embed the data in the page itself, thus delivering the cross-site scripting payload. There are several DOM objects which can serve as an attack vehicle for delivering malicious script to victims browser. Clickjacking The technique works by hiding malicious link/scripts under the cover of the content of a legitimate site. Buttons on a website actually contain invisible links, placed there by the attacker. So, an individual who clicks on an object they can visually see is actually being duped into visiting a malicious page or executing a malicious script. When mouseover is used together with clickjacking, the outcome is devastating. Facebook users have been hit by a clickjacking attack, which tricks people into \u201cliking\u201d a particular Facebook page, thus enabling the attack to spread since Memorial Day 2010. There is not yet effective defence against clickjacking, and disabling JavaScript is the only viable method DataBase Attacks & Defenses SQL injection Attacks It exploits improper input validation in database queries. A successful exploit will allow attackers to access, modify, or delete information in the database. It permits attackers to steal sensitive information stored within the backend databases of affected websites, which may include such things as user credentials, email addresses, personal information, and credit card numbers SELECT USERNAME,PASSWORD from USERS where USERNAME='' AND PASSWORD=''; Here the username & password is the input provided by the user. Suppose an attacker gives the input as \" OR '1'='1'\" in both fields. Therefore the SQL query will look like: SELECT USERNAME,PASSWORD from USERS where USERNAME='' OR '1'='1' AND PASSOWRD='' OR '1'='1'; This query results in a true statement & the user gets logged in. This example depicts the bost basic type of SQL injection SQL Injection Attack Defenses SQL injection can be protected by filtering the query to eliminate malicious syntax, which involves the employment of some tools in order to (a) scan the source code. In addition, the input fields should be restricted to the absolute minimum, typically anywhere from 7-12 characters, and validate any data, e.g., if a user inputs an age make sure the input is an integer with a maximum of 3 digits. VPN A virtual private network (VPN) is a service that offers a secure, reliable connection over a shared public infrastructure such as the Internet. Cisco defines a VPN as an encrypted connection between private networks over a public network. To date, there are three types of VPNs: Remote access Site-to-site Firewall-based Security Breach In spite of the most aggressive steps to protect computers from attacks, attackers sometimes get through. Any event that results in a violation of any of the confidentiality, integrity, or availability (CIA) security tenets is a security breach. Denial of Service Attacks Denial of service (DoS) attacks result in downtime or inability of a user to access a system. DoS attacks impact the availability of tenet of information systems security. A DoS attack is a coordinated attempt to deny service by occupying a computer to perform large amounts of unnecessary tasks. This excessive activity makes the system unavailable to perform legitimate operations Two common types of DoS attacks are as follows: Logic attacks\u2014Logic attacks use software flaws to crash or seriously hinder the performance of remote servers. You can prevent many of these attacks by installing the latest patches to keep your software up to date. Flooding attacks\u2014Flooding attacks overwhelm the victim computer\u2019s CPU, memory, or network resources by sending large numbers of useless requests to the machine. Most DoS attacks target weaknesses in the overall system architecture rather than a software bug or security flaw One popular technique for launching a packet flood is a SYN flood. One of the best defences against DoS attacks is to use intrusion prevention system (IPS) software or devices to detect and stop the attack. Distributed Denial of Service Attacks DDoS attacks differ from regular DoS attacks in their scope. In a DDoS attack, attackers hijack hundreds or even thousands of Internet computers, planting automated attack agents on those systems. The attacker then instructs the agents to bombard the target site with forged messages. This overloads the site and blocks legitimate traffic. The key here is strength in numbers. The attacker does more damage by distributing the attack across multiple computers. Wiretapping Although the term wiretapping is generally associated with voice telephone communications, attackers can also use wiretapping to intercept data communications. Attackers can tap telephone lines and data communication lines. Wiretapping can be active, where the attacker makes modifications to the line. It can also be passive, where an unauthorized user simply listens to the transmission without changing the contents. Passive intrusion can include the copying of data for a subsequent active attack. Two methods of active wiretapping are as follows: Between-the-lines wiretapping\u2014This type of wiretapping does not alter the messages sent by the legitimate user but inserts additional messages into the communication line when the legitimate user pauses. Piggyback-entry wiretapping\u2014This type of wiretapping intercepts and modifies the original message by breaking the communications line and routing the message to another computer that acts as a host. Backdoors Software developers sometimes include hidden access methods, called backdoors, in their programs. Backdoors give developers or support personnel easy access to a system without having to struggle with security controls. The problem is that backdoors don\u2019t always stay hidden. When an attacker discovers a backdoor, he or she can use it to bypass existing security controls such as passwords, encryption, and so on. Where legitimate users log on through front doors using a user ID and password, attackers use backdoors to bypass these normal access controls. Malicious Attacks Birthday Attack Once an attacker compromises a hashed password file, a birthday attack is performed. A birthday attack is a type of cryptographic attack that is used to make a brute-force attack of one-way hashes easier. It is a mathematical exploit that is based on the birthday problem in probability theory. Further Reading: https://www.sciencedirect.com/topics/computer-science/birthday-attack https://www.internetsecurity.tips/birthday-attack/ Brute-Force Password Attacks In a brute-force password attack, the attacker tries different passwords on a system until one of them is successful. Usually, the attacker employs a software program to try all possible combinations of a likely password, user ID, or security code until it locates a match. This occurs rapidly and in sequence. This type of attack is called a brute-force password attack because the attacker simply hammers away at the code. There is no skill or stealth involved\u2014just brute force that eventually breaks the code. Further Reading: https://owasp.org/www-community/attacks/Brute_force_attack https://owasp.org/www-community/controls/Blocking_Brute_Force_Attacks Dictionary Password Attacks A dictionary password attack is a simple attack that relies on users making poor password choices. In a dictionary password attack, a simple password-cracker program takes all the words from a dictionary file and attempts to log on by entering each dictionary entry as a password. Further Reading: https://capec.mitre.org/data/definitions/16.html Replay Attacks Replay attacks involve capturing data packets from a network and retransmitting them to produce an unauthorized effect. The receipt of duplicate, authenticated IP packets may disrupt service or have some other undesired consequence. Systems can be broken through replay attacks when attackers reuse old messages or parts of old messages to deceive system users. This helps intruders to gain information that allows unauthorized access into a system. Further reading: https://study.com/academy/lesson/replay-attack-definition-examples-prevention.html Man-in-the-Middle Attacks A man-in-the-middle attack takes advantage of the multihop process used by many types of networks. In this type of attack, an attacker intercepts messages between two parties before transferring them on to their intended destination. Web spoofing is a type of man-in-the-middle attack in which the user believes a secure session exists with a particular web server. In reality, the secure connection exists only with the attacker, not the webserver. The attacker then establishes a secure connection with the webserver, acting as an invisible go-between. The attacker passes traffic between the user and the webserver. In this way, the attacker can trick the user into supplying passwords, credit card information, and other private data. Further Reading: https://owasp.org/www-community/attacks/Man-in-the-middle_attack Masquerading In a masquerade attack, one user or computer pretends to be another user or computer. Masquerade attacks usually include one of the other forms of active attacks, such as IP address spoofing or replaying. Attackers can capture authentication sequences and then replay them later to log on again to an application or operating system. For example, an attacker might monitor usernames and passwords sent to a weak web application. The attacker could then use the intercepted credentials to log on to the web application and impersonate the user. Further Reading: https://dl.acm.org/doi/book/10.5555/2521792 https://ieeexplore.ieee.org/document/1653228 Eavesdropping Eavesdropping, or sniffing, occurs when a host sets its network interface on promiscuous mode and copies packets that pass by for later analysis. Promiscuous mode enables a network device to intercept and read each network packet(of course given some conditions) given sec, even if the packet\u2019s address doesn\u2019t match the network device. It is possible to attach hardware and software to monitor and analyze all packets on that segment of the transmission media without alerting any other users. Candidates for eavesdropping include satellite, wireless, mobile, and other transmission methods. Social Engineering Attackers often use a deception technique called social engineering to gain access to resources in an IT infrastructure. In nearly all cases, social engineering involves tricking authorized users into carrying out actions for unauthorized users. The success of social engineering attacks depends on the basic tendency of people to want to be helpful. Phreaking Phone phreaking, or simply phreaking, is a slang term that describes the activity of a subculture of people who study, experiment with, or explore telephone systems, telephone company equipment, and systems connected to public telephone networks. Phreaking is the art of exploiting bugs and glitches that exist in the telephone system. Phishing Phishing is a type of fraud in which an attacker attempts to trick the victim into providing private information such as credit card numbers, passwords, dates of birth, bank account numbers, automated teller machine (ATM) PINs, and Social Security numbers. Pharming Pharming is another type of attack that seeks to obtain personal or private financial information through domain spoofing. A pharming attack doesn\u2019t use messages to trick victims into visiting spoofed websites that appear legitimate, however. Instead, pharming \u201cpoisons\u201d a domain name on the domain name server (DNS), a process known as DNS poisoning. The result is that when a user enters the poisoned server\u2019s web address into his or her address bar, that user navigates to the attacker\u2019s site. The user\u2019s browser still shows the correct website, which makes pharming difficult to detect\u2014and therefore more serious. Where phishing attempts to scam people one at a time with an email or instant message, pharming enables scammers to target large groups of people at one time through domain spoofing.","title":"Threat, Attacks & Defences"},{"location":"level101/security/threats_attacks_defences/#part-iii-threats-attacks-defense","text":"","title":"Part III: Threats, Attacks & Defense"},{"location":"level101/security/threats_attacks_defences/#dns-protection","text":"","title":"DNS Protection"},{"location":"level101/security/threats_attacks_defences/#cache-poisoning-attack","text":"Since DNS responses are cached, a quick response can be provided for repeated translations. DNS negative queries are also cached, e.g., misspelt words, and all cached data periodically times out. Cache poisoning is an issue in what is known as pharming. This term is used to describe a hacker\u2019s attack in which a website\u2019s traffic is redirected to a bogus website by forging the DNS mapping. In this case, an attacker attempts to insert a fake address record for an Internet domain into the DNS. If the server accepts the fake record, the cache is poisoned and subsequent requests for the address of the domain are answered with the address of a server controlled by the attacker. As long as the fake entry is cached by the server, browsers or e-mail servers will automatically go to the address provided by the compromised DNS server. the typical time to live (TTL) for cached entries is a couple of hours, thereby permitting ample time for numerous users to be affected by the attack.","title":"Cache Poisoning Attack"},{"location":"level101/security/threats_attacks_defences/#dnssec-security-extension","text":"The long-term solution to these DNS problems is authentication. If a resolver cannot distinguish between valid and invalid data in a response, then add source authentication to verify that the data received in response is equal to the data entered by the zone administrator DNS Security Extensions (DNSSEC) protects against data spoofing and corruption and provides mechanisms to authenticate servers and requests, as well as mechanisms to establish authenticity and integrity. When authenticating DNS responses, each DNS zone signs its data using a private key. It is recommended that this signing be done offline and in advance. The query for a particular record returns the requested resource record set (RRset) and signature (RRSIG) of the requested resource record set. The resolver then authenticates the response using a public key, which is pre-configured or learned via a sequence of key records in the DNS hierarchy. The goals of DNSSEC are to provide authentication and integrity for DNS responses without confidentiality or DDoS protection.","title":"DNSSEC (Security Extension)"},{"location":"level101/security/threats_attacks_defences/#bgp","text":"BGP stands for border gateway protocol. It is a routing protocol that exchanges routing information among multiple Autonomous Systems (AS) An Autonomous System is a collection of routers or networks with the same network policy usually under single administrative control. BGP tells routers which hop to use in order to reach the destination network. BGP is used for both communicating information among routers in an AS (interior) and between multiple ASes (exterior).","title":"BGP"},{"location":"level101/security/threats_attacks_defences/#how-bgp-works","text":"BGP is responsible for finding a path to a destination router & the path it chooses should be the shortest and most reliable one. This decision is done through a protocol known as Link state. With the link-state protocol, each router broadcasts to all other routers in the network the state of its links and IP subnets. Each router then receives information from the other routers and constructs a complete topology view of the entire network. The next-hop routing table is based on this topology view. The link-state protocol uses a famous algorithm in the field of computer science, Dijkstra\u2019s shortest path algorithm: We start from our router considering the path cost to all our direct neighbours. The shortest path is then taken We then re-look at all our neighbours that we can reach and update our link state table with the cost information. We then continue taking the shortest path until every router has been visited.","title":"How BGP Works"},{"location":"level101/security/threats_attacks_defences/#bgp-vulnerabilities","text":"By corrupting the BGP routing table we are able to influence the direction traffic flows on the internet! This action is known as BGP hijacking. Injecting bogus route advertising information into the BGP-distributed routing database by malicious sources, accidentally or routers can disrupt Internet backbone operations. Blackholing traffic: Blackhole route is a network route, i.e., routing table entry, that goes nowhere and packets matching the route prefix are dropped or ignored. Blackhole routes can only be detected by monitoring the lost traffic. Blackhole routes are the best defence against many common viral attacks where the traffic is dropped from infected machines to/from command & control hosts. Infamous BGP Injection attack on Youtube Ex: In 2008, Pakistan decided to block YouTube by creating a BGP route that led into a black hole. Instead, this routing information got transmitted to a hong kong ISP and from there accidentally got propagated to the rest of the world meaning millions were routed through to this black hole and therefore unable to access YouTube. Potentially, the greatest risk to BGP occurs in a denial of service attack in which a router is flooded with more packets than it can handle. Network overload and router resource exhaustion happen when the network begins carrying an excessive number of BGP messages, overloading the router control processors, memory, routing table and reducing the bandwidth available for data traffic. Refer: https://medium.com/bugbountywriteup/bgp-the-weak-link-in-the-internet-what-is-bgp-and-how-do-hackers-exploit-it-d899a68ba5bb Router flapping is another type of attack. Route flapping refers to repetitive changes to the BGP routing table, often several times a minute. Withdrawing and re-advertising at a high-rate can cause a serious problem for routers since they propagate the announcements of routes. If these route flaps happen fast enough, e.g., 30 to 50 times per second, the router becomes overloaded, which eventually prevents convergence on valid routes. The potential impact for Internet users is a slowdown in message delivery, and in some cases, packets may not be delivered at all. BGP Security Border Gateway Protocol Security recommends the use of BGP peer authentication since it is one of the strongest mechanisms for preventing malicious activity. The authentication mechanisms are Internet Protocol Security (IPsec) or BGP MD5. Another method, known as prefix limits, can be used to avoid filling router tables. In this approach, routers should be configured to disable or terminate a BGP peering session, and issue warning messages to administrators when a neighbour sends in excess of a preset number of prefixes. IETF is currently working on improving this space","title":"BGP Vulnerabilities"},{"location":"level101/security/threats_attacks_defences/#web-based-attacks","text":"","title":"Web-Based Attacks"},{"location":"level101/security/threats_attacks_defences/#http-response-splitting-attacks","text":"HTTP response splitting attack may happen where the server script embeds user data in HTTP response headers without appropriate sanitation. This typically happens when the script embeds user data in the redirection URL of a redirection response (HTTP status code 3xx), or when the script embeds user data in a cookie value or name when the response sets a cookie. HTTP response splitting attacks can be used to perform web cache poisoning and cross-site scripting attacks. HTTP response splitting is the attacker\u2019s ability to send a single HTTP request that forces the webserver to form an output stream, which is then interpreted by the target as two HTTP responses instead of one response.","title":"HTTP Response Splitting Attacks"},{"location":"level101/security/threats_attacks_defences/#cross-site-request-forgery-csrf-or-xsrf","text":"A Cross-Site Request Forgery attack tricks the victim\u2019s browser into issuing a command to a vulnerable web application. Vulnerability is caused by browsers automatically including user authentication data, session ID, IP address, Windows domain credentials, etc. with each request. Attackers typically use CSRF to initiate transactions such as transfer funds, login/logout user, close account, access sensitive data, and change account details. The vulnerability is caused by web browsers that automatically include credentials with each request, even for requests caused by a form, script, or image on another site. CSRF can also be dynamically constructed as part of a payload for a cross-site scripting attack All sites relying on automatic credentials are vulnerable. Popular browsers cannot prevent cross-site request forgery. Logging out of high-value sites as soon as possible can mitigate CSRF risk. It is recommended that a high-value website must require a client to manually provide authentication data in the same HTTP request used to perform any operation with security implications. Limiting the lifetime of session cookies can also reduce the chance of being used by other malicious sites. OWASP recommends website developers include a required security token in HTTP requests associated with sensitive business functions in order to mitigate CSRF attacks","title":"Cross-Site Request Forgery (CSRF or XSRF)"},{"location":"level101/security/threats_attacks_defences/#cross-site-scripting-xss-attacks","text":"Cross-Site Scripting occurs when dynamically generated web pages display user input, such as login information, that is not properly validated, allowing an attacker to embed malicious scripts into the generated page and then execute the script on the machine of any user that views the site. If successful, Cross-Site Scripting vulnerabilities can be exploited to manipulate or steal cookies, create requests that can be mistaken for those of a valid user, compromise confidential information, or execute malicious code on end-user systems. Cross-Site Scripting (XSS or CSS) attacks involve the execution of malicious scripts on the victim\u2019s browser. The victim is simply a user\u2019s host and not the server. XSS results from a failure to validate user input by a web-based application.","title":"Cross-Site Scripting (XSS) Attacks"},{"location":"level101/security/threats_attacks_defences/#document-object-model-dom-xss-attacks","text":"The Document Object Model (DOM) based XSS does not require the webserver to receive the XSS payload for a successful attack. The attacker abuses the runtime by embedding their data on the client-side. An attacker can force the client (browser) to render the page with parts of the DOM controlled by the attacker. When the page is rendered and the data is processed by the page, typically by a client-side HTML-embedded script such as JavaScript, the page\u2019s code may insecurely embed the data in the page itself, thus delivering the cross-site scripting payload. There are several DOM objects which can serve as an attack vehicle for delivering malicious script to victims browser.","title":"Document Object Model (DOM) XSS Attacks"},{"location":"level101/security/threats_attacks_defences/#clickjacking","text":"The technique works by hiding malicious link/scripts under the cover of the content of a legitimate site. Buttons on a website actually contain invisible links, placed there by the attacker. So, an individual who clicks on an object they can visually see is actually being duped into visiting a malicious page or executing a malicious script. When mouseover is used together with clickjacking, the outcome is devastating. Facebook users have been hit by a clickjacking attack, which tricks people into \u201cliking\u201d a particular Facebook page, thus enabling the attack to spread since Memorial Day 2010. There is not yet effective defence against clickjacking, and disabling JavaScript is the only viable method","title":"Clickjacking"},{"location":"level101/security/threats_attacks_defences/#database-attacks-defenses","text":"","title":"DataBase Attacks & Defenses"},{"location":"level101/security/threats_attacks_defences/#sql-injection-attacks","text":"It exploits improper input validation in database queries. A successful exploit will allow attackers to access, modify, or delete information in the database. It permits attackers to steal sensitive information stored within the backend databases of affected websites, which may include such things as user credentials, email addresses, personal information, and credit card numbers SELECT USERNAME,PASSWORD from USERS where USERNAME='' AND PASSWORD=''; Here the username & password is the input provided by the user. Suppose an attacker gives the input as \" OR '1'='1'\" in both fields. Therefore the SQL query will look like: SELECT USERNAME,PASSWORD from USERS where USERNAME='' OR '1'='1' AND PASSOWRD='' OR '1'='1'; This query results in a true statement & the user gets logged in. This example depicts the bost basic type of SQL injection","title":"SQL injection Attacks"},{"location":"level101/security/threats_attacks_defences/#sql-injection-attack-defenses","text":"SQL injection can be protected by filtering the query to eliminate malicious syntax, which involves the employment of some tools in order to (a) scan the source code. In addition, the input fields should be restricted to the absolute minimum, typically anywhere from 7-12 characters, and validate any data, e.g., if a user inputs an age make sure the input is an integer with a maximum of 3 digits.","title":"SQL Injection Attack Defenses"},{"location":"level101/security/threats_attacks_defences/#vpn","text":"A virtual private network (VPN) is a service that offers a secure, reliable connection over a shared public infrastructure such as the Internet. Cisco defines a VPN as an encrypted connection between private networks over a public network. To date, there are three types of VPNs: Remote access Site-to-site Firewall-based","title":"VPN"},{"location":"level101/security/threats_attacks_defences/#security-breach","text":"In spite of the most aggressive steps to protect computers from attacks, attackers sometimes get through. Any event that results in a violation of any of the confidentiality, integrity, or availability (CIA) security tenets is a security breach.","title":"Security Breach"},{"location":"level101/security/threats_attacks_defences/#denial-of-service-attacks","text":"Denial of service (DoS) attacks result in downtime or inability of a user to access a system. DoS attacks impact the availability of tenet of information systems security. A DoS attack is a coordinated attempt to deny service by occupying a computer to perform large amounts of unnecessary tasks. This excessive activity makes the system unavailable to perform legitimate operations Two common types of DoS attacks are as follows: Logic attacks\u2014Logic attacks use software flaws to crash or seriously hinder the performance of remote servers. You can prevent many of these attacks by installing the latest patches to keep your software up to date. Flooding attacks\u2014Flooding attacks overwhelm the victim computer\u2019s CPU, memory, or network resources by sending large numbers of useless requests to the machine. Most DoS attacks target weaknesses in the overall system architecture rather than a software bug or security flaw One popular technique for launching a packet flood is a SYN flood. One of the best defences against DoS attacks is to use intrusion prevention system (IPS) software or devices to detect and stop the attack.","title":"Denial of Service Attacks"},{"location":"level101/security/threats_attacks_defences/#distributed-denial-of-service-attacks","text":"DDoS attacks differ from regular DoS attacks in their scope. In a DDoS attack, attackers hijack hundreds or even thousands of Internet computers, planting automated attack agents on those systems. The attacker then instructs the agents to bombard the target site with forged messages. This overloads the site and blocks legitimate traffic. The key here is strength in numbers. The attacker does more damage by distributing the attack across multiple computers.","title":"Distributed Denial of Service Attacks"},{"location":"level101/security/threats_attacks_defences/#wiretapping","text":"Although the term wiretapping is generally associated with voice telephone communications, attackers can also use wiretapping to intercept data communications. Attackers can tap telephone lines and data communication lines. Wiretapping can be active, where the attacker makes modifications to the line. It can also be passive, where an unauthorized user simply listens to the transmission without changing the contents. Passive intrusion can include the copying of data for a subsequent active attack. Two methods of active wiretapping are as follows: Between-the-lines wiretapping\u2014This type of wiretapping does not alter the messages sent by the legitimate user but inserts additional messages into the communication line when the legitimate user pauses. Piggyback-entry wiretapping\u2014This type of wiretapping intercepts and modifies the original message by breaking the communications line and routing the message to another computer that acts as a host.","title":"Wiretapping"},{"location":"level101/security/threats_attacks_defences/#backdoors","text":"Software developers sometimes include hidden access methods, called backdoors, in their programs. Backdoors give developers or support personnel easy access to a system without having to struggle with security controls. The problem is that backdoors don\u2019t always stay hidden. When an attacker discovers a backdoor, he or she can use it to bypass existing security controls such as passwords, encryption, and so on. Where legitimate users log on through front doors using a user ID and password, attackers use backdoors to bypass these normal access controls.","title":"Backdoors"},{"location":"level101/security/threats_attacks_defences/#malicious-attacks","text":"","title":"Malicious Attacks"},{"location":"level101/security/threats_attacks_defences/#birthday-attack","text":"Once an attacker compromises a hashed password file, a birthday attack is performed. A birthday attack is a type of cryptographic attack that is used to make a brute-force attack of one-way hashes easier. It is a mathematical exploit that is based on the birthday problem in probability theory. Further Reading: https://www.sciencedirect.com/topics/computer-science/birthday-attack https://www.internetsecurity.tips/birthday-attack/","title":"Birthday Attack"},{"location":"level101/security/threats_attacks_defences/#brute-force-password-attacks","text":"In a brute-force password attack, the attacker tries different passwords on a system until one of them is successful. Usually, the attacker employs a software program to try all possible combinations of a likely password, user ID, or security code until it locates a match. This occurs rapidly and in sequence. This type of attack is called a brute-force password attack because the attacker simply hammers away at the code. There is no skill or stealth involved\u2014just brute force that eventually breaks the code. Further Reading: https://owasp.org/www-community/attacks/Brute_force_attack https://owasp.org/www-community/controls/Blocking_Brute_Force_Attacks","title":"Brute-Force Password Attacks"},{"location":"level101/security/threats_attacks_defences/#dictionary-password-attacks","text":"A dictionary password attack is a simple attack that relies on users making poor password choices. In a dictionary password attack, a simple password-cracker program takes all the words from a dictionary file and attempts to log on by entering each dictionary entry as a password. Further Reading: https://capec.mitre.org/data/definitions/16.html","title":"Dictionary Password Attacks"},{"location":"level101/security/threats_attacks_defences/#replay-attacks","text":"Replay attacks involve capturing data packets from a network and retransmitting them to produce an unauthorized effect. The receipt of duplicate, authenticated IP packets may disrupt service or have some other undesired consequence. Systems can be broken through replay attacks when attackers reuse old messages or parts of old messages to deceive system users. This helps intruders to gain information that allows unauthorized access into a system. Further reading: https://study.com/academy/lesson/replay-attack-definition-examples-prevention.html","title":"Replay Attacks"},{"location":"level101/security/threats_attacks_defences/#man-in-the-middle-attacks","text":"A man-in-the-middle attack takes advantage of the multihop process used by many types of networks. In this type of attack, an attacker intercepts messages between two parties before transferring them on to their intended destination. Web spoofing is a type of man-in-the-middle attack in which the user believes a secure session exists with a particular web server. In reality, the secure connection exists only with the attacker, not the webserver. The attacker then establishes a secure connection with the webserver, acting as an invisible go-between. The attacker passes traffic between the user and the webserver. In this way, the attacker can trick the user into supplying passwords, credit card information, and other private data. Further Reading: https://owasp.org/www-community/attacks/Man-in-the-middle_attack","title":"Man-in-the-Middle Attacks"},{"location":"level101/security/threats_attacks_defences/#masquerading","text":"In a masquerade attack, one user or computer pretends to be another user or computer. Masquerade attacks usually include one of the other forms of active attacks, such as IP address spoofing or replaying. Attackers can capture authentication sequences and then replay them later to log on again to an application or operating system. For example, an attacker might monitor usernames and passwords sent to a weak web application. The attacker could then use the intercepted credentials to log on to the web application and impersonate the user. Further Reading: https://dl.acm.org/doi/book/10.5555/2521792 https://ieeexplore.ieee.org/document/1653228","title":"Masquerading"},{"location":"level101/security/threats_attacks_defences/#eavesdropping","text":"Eavesdropping, or sniffing, occurs when a host sets its network interface on promiscuous mode and copies packets that pass by for later analysis. Promiscuous mode enables a network device to intercept and read each network packet(of course given some conditions) given sec, even if the packet\u2019s address doesn\u2019t match the network device. It is possible to attach hardware and software to monitor and analyze all packets on that segment of the transmission media without alerting any other users. Candidates for eavesdropping include satellite, wireless, mobile, and other transmission methods.","title":"Eavesdropping"},{"location":"level101/security/threats_attacks_defences/#social-engineering","text":"Attackers often use a deception technique called social engineering to gain access to resources in an IT infrastructure. In nearly all cases, social engineering involves tricking authorized users into carrying out actions for unauthorized users. The success of social engineering attacks depends on the basic tendency of people to want to be helpful.","title":"Social Engineering"},{"location":"level101/security/threats_attacks_defences/#phreaking","text":"Phone phreaking, or simply phreaking, is a slang term that describes the activity of a subculture of people who study, experiment with, or explore telephone systems, telephone company equipment, and systems connected to public telephone networks. Phreaking is the art of exploiting bugs and glitches that exist in the telephone system.","title":"Phreaking"},{"location":"level101/security/threats_attacks_defences/#phishing","text":"Phishing is a type of fraud in which an attacker attempts to trick the victim into providing private information such as credit card numbers, passwords, dates of birth, bank account numbers, automated teller machine (ATM) PINs, and Social Security numbers.","title":"Phishing"},{"location":"level101/security/threats_attacks_defences/#pharming","text":"Pharming is another type of attack that seeks to obtain personal or private financial information through domain spoofing. A pharming attack doesn\u2019t use messages to trick victims into visiting spoofed websites that appear legitimate, however. Instead, pharming \u201cpoisons\u201d a domain name on the domain name server (DNS), a process known as DNS poisoning. The result is that when a user enters the poisoned server\u2019s web address into his or her address bar, that user navigates to the attacker\u2019s site. The user\u2019s browser still shows the correct website, which makes pharming difficult to detect\u2014and therefore more serious. Where phishing attempts to scam people one at a time with an email or instant message, pharming enables scammers to target large groups of people at one time through domain spoofing.","title":"Pharming"},{"location":"level101/security/writing_secure_code/","text":"PART IV: Writing Secure Code & More The first and most important step in reducing security and reliability issues is to educate developers. However, even the best-trained engineers make mistakes, security experts can write insecure code and SREs can miss reliability issues. It\u2019s difficult to keep the many considerations and tradeoffs involved in building secure and reliable systems in mind simultaneously, especially if you\u2019re also responsible for producing software. Use frameworks to enforce security and reliability while writing code A better approach is to handle security and reliability in common frameworks, languages, and libraries. Ideally, libraries only expose an interface that makes writing code with common classes of security vulnerabilities impossible. Multiple applications can use each library or framework. When domain experts fix an issue, they remove it from all the applications the framework supports, allowing this engineering approach to scale better. Common Security Vulnerabilities In large codebases, a handful of classes account for the majority of security vulnerabilities, despite ongoing efforts to educate developers and introduce code review. OWASP and SANS publish lists of common vulnerability classes Write Simple Code Try to keep your code clean and simple. Avoid Multi-Level Nesting Multilevel nesting is a common anti-pattern that can lead to simple mistakes. If the error is in the most common code path, it will likely be captured by the unit tests. However, unit tests don\u2019t always check error handling paths in multilevel nested code. The error might result in decreased reliability (for example, if the service crashes when it mishandles an error) or a security vulnerability (like a mishandled authorization check error). Eliminate YAGNI Smells Sometimes developers overengineer solutions by adding functionality that may be useful in the future, \u201cjust in case.\u201d This goes against the YAGNI (You Aren\u2019t Gonna Need It) principle, which recommends implementing only the code that you need. YAGNI code adds unnecessary complexity because it needs to be documented, tested, and maintained. To summarize, avoiding YAGNI code leads to improved reliability, and simpler code leads to fewer security bugs, fewer opportunities to make mistakes, and less developer time spent maintaining unused code. Repay Technical Debt It is a common practice for developers to mark places that require further attention with TODO or FIXME annotations. In the short term, this habit can accelerate the delivery velocity for the most critical functionality, and allow a team to meet early deadlines\u2014but it also incurs technical debt. Still, it\u2019s not necessarily a bad practice, as long as you have a clear process (and allocate time) for repaying such debt. Refactoring Refactoring is the most effective way to keep a codebase clean and simple. Even a healthy codebase occasionally needs to be Regardless of the reasons behind refactoring, you should always follow one golden rule: never mix refactoring and functional changes in a single commit to the code repository. Refactoring changes are typically significant and can be difficult to understand. If a commit also includes functional changes, there\u2019s a higher risk that an author or reviewer might overlook bugs. Unit Testing Unit testing can increase system security and reliability by pinpointing a wide range of bugs in individual software components before a release. This technique involves breaking software components into smaller, self-contained \u201cunits\u201d that have no external dependencies, and then testing each unit. Fuzz Testing Fuzz testing is a technique that complements the previously mentioned testing techniques. Fuzzing involves using a fuzzing engine to generate a large number of candidate inputs that are then passed through a fuzz driver to the fuzz target. The fuzzer then analyzes how the system handles the input. Complex inputs handled by all kinds of software are popular targets for fuzzing - for example, file parsers, compression algorithms, network protocol implementation and audio codec. Integration Testing Integration testing moves beyond individual units and abstractions, replacing fake or stubbed-out implementations of abstractions like databases or network services with real implementations. As a result, integration tests exercise more complete code paths. Because you must initialize and configure these other dependencies, integration testing may be slower and flakier than unit testing\u2014to execute the test, this approach incorporates real-world variables like network latency as services communicate end-to-end. As you move from testing individual low-level units of code to testing how they interact when composed together, the net result is a higher degree of confidence that the system is behaving as expected. Last But not the least Code Reviews Rely on Automation Don\u2019t check in Secrets Verifiable Builds","title":"Writing Secure code"},{"location":"level101/security/writing_secure_code/#part-iv-writing-secure-code-more","text":"The first and most important step in reducing security and reliability issues is to educate developers. However, even the best-trained engineers make mistakes, security experts can write insecure code and SREs can miss reliability issues. It\u2019s difficult to keep the many considerations and tradeoffs involved in building secure and reliable systems in mind simultaneously, especially if you\u2019re also responsible for producing software.","title":"PART IV: Writing Secure Code & More"},{"location":"level101/security/writing_secure_code/#use-frameworks-to-enforce-security-and-reliability-while-writing-code","text":"A better approach is to handle security and reliability in common frameworks, languages, and libraries. Ideally, libraries only expose an interface that makes writing code with common classes of security vulnerabilities impossible. Multiple applications can use each library or framework. When domain experts fix an issue, they remove it from all the applications the framework supports, allowing this engineering approach to scale better.","title":"Use frameworks to enforce security and reliability while writing code"},{"location":"level101/security/writing_secure_code/#common-security-vulnerabilities","text":"In large codebases, a handful of classes account for the majority of security vulnerabilities, despite ongoing efforts to educate developers and introduce code review. OWASP and SANS publish lists of common vulnerability classes","title":"Common Security Vulnerabilities"},{"location":"level101/security/writing_secure_code/#write-simple-code","text":"Try to keep your code clean and simple.","title":"Write Simple Code"},{"location":"level101/security/writing_secure_code/#avoid-multi-level-nesting","text":"Multilevel nesting is a common anti-pattern that can lead to simple mistakes. If the error is in the most common code path, it will likely be captured by the unit tests. However, unit tests don\u2019t always check error handling paths in multilevel nested code. The error might result in decreased reliability (for example, if the service crashes when it mishandles an error) or a security vulnerability (like a mishandled authorization check error).","title":"Avoid Multi-Level Nesting"},{"location":"level101/security/writing_secure_code/#eliminate-yagni-smells","text":"Sometimes developers overengineer solutions by adding functionality that may be useful in the future, \u201cjust in case.\u201d This goes against the YAGNI (You Aren\u2019t Gonna Need It) principle, which recommends implementing only the code that you need. YAGNI code adds unnecessary complexity because it needs to be documented, tested, and maintained. To summarize, avoiding YAGNI code leads to improved reliability, and simpler code leads to fewer security bugs, fewer opportunities to make mistakes, and less developer time spent maintaining unused code.","title":"Eliminate YAGNI Smells"},{"location":"level101/security/writing_secure_code/#repay-technical-debt","text":"It is a common practice for developers to mark places that require further attention with TODO or FIXME annotations. In the short term, this habit can accelerate the delivery velocity for the most critical functionality, and allow a team to meet early deadlines\u2014but it also incurs technical debt. Still, it\u2019s not necessarily a bad practice, as long as you have a clear process (and allocate time) for repaying such debt.","title":"Repay Technical Debt"},{"location":"level101/security/writing_secure_code/#refactoring","text":"Refactoring is the most effective way to keep a codebase clean and simple. Even a healthy codebase occasionally needs to be Regardless of the reasons behind refactoring, you should always follow one golden rule: never mix refactoring and functional changes in a single commit to the code repository. Refactoring changes are typically significant and can be difficult to understand. If a commit also includes functional changes, there\u2019s a higher risk that an author or reviewer might overlook bugs.","title":"Refactoring"},{"location":"level101/security/writing_secure_code/#unit-testing","text":"Unit testing can increase system security and reliability by pinpointing a wide range of bugs in individual software components before a release. This technique involves breaking software components into smaller, self-contained \u201cunits\u201d that have no external dependencies, and then testing each unit.","title":"Unit Testing"},{"location":"level101/security/writing_secure_code/#fuzz-testing","text":"Fuzz testing is a technique that complements the previously mentioned testing techniques. Fuzzing involves using a fuzzing engine to generate a large number of candidate inputs that are then passed through a fuzz driver to the fuzz target. The fuzzer then analyzes how the system handles the input. Complex inputs handled by all kinds of software are popular targets for fuzzing - for example, file parsers, compression algorithms, network protocol implementation and audio codec.","title":"Fuzz Testing"},{"location":"level101/security/writing_secure_code/#integration-testing","text":"Integration testing moves beyond individual units and abstractions, replacing fake or stubbed-out implementations of abstractions like databases or network services with real implementations. As a result, integration tests exercise more complete code paths. Because you must initialize and configure these other dependencies, integration testing may be slower and flakier than unit testing\u2014to execute the test, this approach incorporates real-world variables like network latency as services communicate end-to-end. As you move from testing individual low-level units of code to testing how they interact when composed together, the net result is a higher degree of confidence that the system is behaving as expected.","title":"Integration Testing"},{"location":"level101/security/writing_secure_code/#last-but-not-the-least","text":"Code Reviews Rely on Automation Don\u2019t check in Secrets Verifiable Builds","title":"Last But not the least"},{"location":"level101/systems_design/availability/","text":"HA - Availability - Common \u201cNines\u201d Availability is generally expressed as \u201cNines\u201d, common \u2018Nines\u2019 are listed below. Availability % Downtime per year Downtime per month Downtime per week Downtime per day 99%(Two Nines) 3.65 days 7.31 hours 1.68 hours 14.40 minutes 99.5%(Two and a half Nines) 1.83 days 3.65 hours 50.40 minutes 7.20 minutes 99.9%(Three Nines) 8.77 hours 43.83 minutes 10.08 minutes 1.44 minutes 99.95%(Three and a half Nines) 4.38 hours 21.92 minutes 5.04 minutes 43.20 seconds 99.99%(Four Nines) 52.60 minutes 4.38 minutes 1.01 minutes 8.64 seconds 99.995%(Four and a half Nines) 26.30 minutes 2.19 minutes 30.24 seconds 4.32 seconds 99.999%(Five Nines) 5.26 minutes 26.30 seconds 6.05 seconds 864.0 ms Refer https://en.wikipedia.org/wiki/High_availability#Percentage_calculation HA - Availability Serial Components A System with components is operating in the series If the failure of a part leads to the combination becoming inoperable. For example, if LB in our architecture fails, all access to app tiers will fail. LB and app tiers are connected serially. The combined availability of the system is the product of individual components availability A = Ax x Ay x \u2026.. Refer http://www.eventhelix.com/RealtimeMantra/FaultHandling/system_reliability_availability.htm HA - Availability Parallel Components A System with components is operating in parallel If the failure of a part leads to the other part taking over the operations of the failed part. If we have more than one LB and if the rest of the LBs can take over the traffic during one LB failure then LBs are operating in parallel The combined availability of the system is A = 1 - ( (1-Ax) x (1-Ax) x \u2026.. ) Refer http://www.eventhelix.com/RealtimeMantra/FaultHandling/system_reliability_availability.htm HA - Core Principles Elimination of single points of failure (SPOF) This means adding redundancy to the system so that the failure of a component does not mean failure of the entire system. Reliable crossover In redundant systems, the crossover point itself tends to become a single point of failure. Reliable systems must provide for reliable crossover. Detection of failures as they occur If the two principles above are observed, then a user may never see a failure Refer https://en.wikipedia.org/wiki/High_availability#Principles HA - SPOF WHAT: Never implement and always eliminate single points of failure. WHEN TO USE: During architecture reviews and new designs. HOW TO USE: Identify single instances on architectural diagrams. Strive for active/active configurations. At the very least we should have a standby to take control when active instances fail. WHY: Maximize availability through multiple instances. KEY TAKEAWAYS: Strive for active/active rather than active/passive solutions. Use load balancers to balance traffic across instances of a service. Use control services with active/passive instances for patterns that require singletons. HA - Reliable Crossover WHAT: Ensure when system components failover they do so reliably. WHEN TO USE: During architecture reviews, failure modeling, and designs. HOW TO USE: Identify how available a system is during the crossover and ensure it is within acceptable limits. WHY: Maximize availability and ensure data handling semantics are preserved. KEY TAKEAWAYS: Strive for active/active rather than active/passive solutions, they have a lesser risk of cross over being unreliable. Use LB and the right load balancing methods to ensure reliable failover. Model and build your data systems to ensure data is correctly handled when crossover happens. Generally, DB systems follow active/passive semantics for writes. Masters accept writes and when the master goes down, the follower is promoted to master(active from being passive) to accept writes. We have to be careful here that the cutover never introduces more than one master. This problem is called a split brain. Applications in SRE role SRE works on deciding an acceptable SLA and make sure the system is available to achieve the SLA SRE is involved in architecture design right from building the data center to make sure the site is not affected by a network switch, hardware, power, or software failures SRE also run mock drills of failures to see how the system behaves in uncharted territory and comes up with a plan to improve availability if there are misses. https://engineering.linkedin.com/blog/2017/11/resilience-engineering-at-linkedin-with-project-waterbear Post our understanding about HA, our architecture diagram looks something like this below","title":"Availability"},{"location":"level101/systems_design/availability/#ha-availability-common-nines","text":"Availability is generally expressed as \u201cNines\u201d, common \u2018Nines\u2019 are listed below. Availability % Downtime per year Downtime per month Downtime per week Downtime per day 99%(Two Nines) 3.65 days 7.31 hours 1.68 hours 14.40 minutes 99.5%(Two and a half Nines) 1.83 days 3.65 hours 50.40 minutes 7.20 minutes 99.9%(Three Nines) 8.77 hours 43.83 minutes 10.08 minutes 1.44 minutes 99.95%(Three and a half Nines) 4.38 hours 21.92 minutes 5.04 minutes 43.20 seconds 99.99%(Four Nines) 52.60 minutes 4.38 minutes 1.01 minutes 8.64 seconds 99.995%(Four and a half Nines) 26.30 minutes 2.19 minutes 30.24 seconds 4.32 seconds 99.999%(Five Nines) 5.26 minutes 26.30 seconds 6.05 seconds 864.0 ms","title":"HA - Availability - Common \u201cNines\u201d"},{"location":"level101/systems_design/availability/#refer","text":"https://en.wikipedia.org/wiki/High_availability#Percentage_calculation","title":"Refer"},{"location":"level101/systems_design/availability/#ha-availability-serial-components","text":"A System with components is operating in the series If the failure of a part leads to the combination becoming inoperable. For example, if LB in our architecture fails, all access to app tiers will fail. LB and app tiers are connected serially. The combined availability of the system is the product of individual components availability A = Ax x Ay x \u2026..","title":"HA - Availability Serial Components"},{"location":"level101/systems_design/availability/#refer_1","text":"http://www.eventhelix.com/RealtimeMantra/FaultHandling/system_reliability_availability.htm","title":"Refer"},{"location":"level101/systems_design/availability/#ha-availability-parallel-components","text":"A System with components is operating in parallel If the failure of a part leads to the other part taking over the operations of the failed part. If we have more than one LB and if the rest of the LBs can take over the traffic during one LB failure then LBs are operating in parallel The combined availability of the system is A = 1 - ( (1-Ax) x (1-Ax) x \u2026.. )","title":"HA - Availability Parallel Components"},{"location":"level101/systems_design/availability/#refer_2","text":"http://www.eventhelix.com/RealtimeMantra/FaultHandling/system_reliability_availability.htm","title":"Refer"},{"location":"level101/systems_design/availability/#ha-core-principles","text":"Elimination of single points of failure (SPOF) This means adding redundancy to the system so that the failure of a component does not mean failure of the entire system. Reliable crossover In redundant systems, the crossover point itself tends to become a single point of failure. Reliable systems must provide for reliable crossover. Detection of failures as they occur If the two principles above are observed, then a user may never see a failure","title":"HA - Core Principles"},{"location":"level101/systems_design/availability/#refer_3","text":"https://en.wikipedia.org/wiki/High_availability#Principles","title":"Refer"},{"location":"level101/systems_design/availability/#ha-spof","text":"WHAT: Never implement and always eliminate single points of failure. WHEN TO USE: During architecture reviews and new designs. HOW TO USE: Identify single instances on architectural diagrams. Strive for active/active configurations. At the very least we should have a standby to take control when active instances fail. WHY: Maximize availability through multiple instances. KEY TAKEAWAYS: Strive for active/active rather than active/passive solutions. Use load balancers to balance traffic across instances of a service. Use control services with active/passive instances for patterns that require singletons.","title":"HA - SPOF"},{"location":"level101/systems_design/availability/#ha-reliable-crossover","text":"WHAT: Ensure when system components failover they do so reliably. WHEN TO USE: During architecture reviews, failure modeling, and designs. HOW TO USE: Identify how available a system is during the crossover and ensure it is within acceptable limits. WHY: Maximize availability and ensure data handling semantics are preserved. KEY TAKEAWAYS: Strive for active/active rather than active/passive solutions, they have a lesser risk of cross over being unreliable. Use LB and the right load balancing methods to ensure reliable failover. Model and build your data systems to ensure data is correctly handled when crossover happens. Generally, DB systems follow active/passive semantics for writes. Masters accept writes and when the master goes down, the follower is promoted to master(active from being passive) to accept writes. We have to be careful here that the cutover never introduces more than one master. This problem is called a split brain.","title":"HA - Reliable Crossover"},{"location":"level101/systems_design/availability/#applications-in-sre-role","text":"SRE works on deciding an acceptable SLA and make sure the system is available to achieve the SLA SRE is involved in architecture design right from building the data center to make sure the site is not affected by a network switch, hardware, power, or software failures SRE also run mock drills of failures to see how the system behaves in uncharted territory and comes up with a plan to improve availability if there are misses. https://engineering.linkedin.com/blog/2017/11/resilience-engineering-at-linkedin-with-project-waterbear Post our understanding about HA, our architecture diagram looks something like this below","title":"Applications in SRE role"},{"location":"level101/systems_design/conclusion/","text":"Conclusion Armed with these principles, we hope the course will give a fresh perspective to design software systems. It might be over-engineering to get all this on day zero. But some are really important from day 0 like eliminating single points of failure, making scalable services by just increasing replicas. As a bottleneck is reached, we can split code by services, shard data to scale. As the organization matures, bringing in chaos engineering to measure how systems react to failure will help in designing robust software systems.","title":"Conclusion"},{"location":"level101/systems_design/conclusion/#conclusion","text":"Armed with these principles, we hope the course will give a fresh perspective to design software systems. It might be over-engineering to get all this on day zero. But some are really important from day 0 like eliminating single points of failure, making scalable services by just increasing replicas. As a bottleneck is reached, we can split code by services, shard data to scale. As the organization matures, bringing in chaos engineering to measure how systems react to failure will help in designing robust software systems.","title":"Conclusion"},{"location":"level101/systems_design/fault-tolerance/","text":"Fault Tolerance Failures are not avoidable in any system and will happen all the time, hence we need to build systems that can tolerate failures or recover from them. In systems, failure is the norm rather than the exception. \"Anything that can go wrong will go wrong\u201d -- Murphy\u2019s Law \u201cComplex systems contain changing mixtures of failures latent within them\u201d -- How Complex Systems Fail. Fault Tolerance - Failure Metrics Common failure metrics that get measured and tracked for any system. Mean time to repair (MTTR): The average time to repair and restore a failed system. Mean time between failures (MTBF): The average operational time between one device failure or system breakdown and the next. Mean time to failure (MTTF): The average time a device or system is expected to function before it fails. Mean time to detect (MTTD): The average time between the onset of a problem and when the organization detects it. Mean time to investigate (MTTI): The average time between the detection of an incident and when the organization begins to investigate its cause and solution. Mean time to restore service (MTRS): The average elapsed time from the detection of an incident until the affected system or component is again available to users. Mean time between system incidents (MTBSI): The average elapsed time between the detection of two consecutive incidents. MTBSI can be calculated by adding MTBF and MTRS (MTBSI = MTBF + MTRS). Failure rate: Another reliability metric, which measures the frequency with which a component or system fails. It is expressed as a number of failures over a unit of time. Refer https://www.splunk.com/en_us/data-insider/what-is-mean-time-to-repair.html Fault Tolerance - Fault Isolation Terms Systems should have a short circuit. Say in our content sharing system, if \u201cNotifications\u201d is not working, the site should gracefully handle that failure by removing the functionality instead of taking the whole site down. Swimlane is one of the commonly used fault isolation methodologies. Swimlane adds a barrier to the service from other services so that failure on either of them won\u2019t affect the other. Say we roll out a new feature \u2018Advertisement\u2019 in our content sharing app. We can have two architectures If Ads are generated on the fly synchronously during each Newsfeed request, the faults in the Ads feature get propagated to the Newsfeed feature. Instead if we swimlane the \u201cGeneration of Ads\u201d service and use a shared storage to populate Newsfeed App, Ads failures won\u2019t cascade to Newsfeed, and worst case if Ads don\u2019t meet SLA , we can have Newsfeed without Ads. Let's take another example, we have come up with a new model for our Content sharing App. Here we roll out an enterprise content sharing App where enterprises pay for the service and the content should never be shared outside the enterprise. Swimlane Principles Principle 1: Nothing is shared (also known as \u201cshare as little as possible\u201d). The less that is shared within a swim lane, the more fault isolative the swim lane becomes. (as shown in Enterprise use-case) Principle 2: Nothing crosses a swim lane boundary. Synchronous (defined by expecting a request\u2014not the transfer protocol) communication never crosses a swim lane boundary; if it does, the boundary is drawn incorrectly. (as shown in Ads feature) Swimlane Approaches Approach 1: Swim lane the money-maker. Never allow your cash register to be compromised by other systems. (Tier 1 vs Tier 2 in enterprise use case) Approach 2: Swim lane the biggest sources of incidents. Identify the recurring causes of pain and isolate them. (if Ads feature is in code yellow, swim laning it is the best option) Approach 3: Swim lane natural barriers. Customer boundaries make good swim lanes. (Public vs Enterprise customers) Refer https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch21.html#ch21 Applications in SRE role Work with the DC tech or cloud team to distribute infrastructure such that its immune to switch or power failures by creating fault zones within a Data Center https://docs.microsoft.com/en-us/azure/virtual-machines/manage-availability#use-availability-zones-to-protect-from-datacenter-level-failures Work with the partners and design interaction between services such that one service breakdown is not amplified in a cascading fashion to all upstreams","title":"Fault Tolerance"},{"location":"level101/systems_design/fault-tolerance/#fault-tolerance","text":"Failures are not avoidable in any system and will happen all the time, hence we need to build systems that can tolerate failures or recover from them. In systems, failure is the norm rather than the exception. \"Anything that can go wrong will go wrong\u201d -- Murphy\u2019s Law \u201cComplex systems contain changing mixtures of failures latent within them\u201d -- How Complex Systems Fail.","title":"Fault Tolerance"},{"location":"level101/systems_design/fault-tolerance/#fault-tolerance-failure-metrics","text":"Common failure metrics that get measured and tracked for any system. Mean time to repair (MTTR): The average time to repair and restore a failed system. Mean time between failures (MTBF): The average operational time between one device failure or system breakdown and the next. Mean time to failure (MTTF): The average time a device or system is expected to function before it fails. Mean time to detect (MTTD): The average time between the onset of a problem and when the organization detects it. Mean time to investigate (MTTI): The average time between the detection of an incident and when the organization begins to investigate its cause and solution. Mean time to restore service (MTRS): The average elapsed time from the detection of an incident until the affected system or component is again available to users. Mean time between system incidents (MTBSI): The average elapsed time between the detection of two consecutive incidents. MTBSI can be calculated by adding MTBF and MTRS (MTBSI = MTBF + MTRS). Failure rate: Another reliability metric, which measures the frequency with which a component or system fails. It is expressed as a number of failures over a unit of time.","title":"Fault Tolerance - Failure Metrics"},{"location":"level101/systems_design/fault-tolerance/#refer","text":"https://www.splunk.com/en_us/data-insider/what-is-mean-time-to-repair.html","title":"Refer"},{"location":"level101/systems_design/fault-tolerance/#fault-tolerance-fault-isolation-terms","text":"Systems should have a short circuit. Say in our content sharing system, if \u201cNotifications\u201d is not working, the site should gracefully handle that failure by removing the functionality instead of taking the whole site down. Swimlane is one of the commonly used fault isolation methodologies. Swimlane adds a barrier to the service from other services so that failure on either of them won\u2019t affect the other. Say we roll out a new feature \u2018Advertisement\u2019 in our content sharing app. We can have two architectures If Ads are generated on the fly synchronously during each Newsfeed request, the faults in the Ads feature get propagated to the Newsfeed feature. Instead if we swimlane the \u201cGeneration of Ads\u201d service and use a shared storage to populate Newsfeed App, Ads failures won\u2019t cascade to Newsfeed, and worst case if Ads don\u2019t meet SLA , we can have Newsfeed without Ads. Let's take another example, we have come up with a new model for our Content sharing App. Here we roll out an enterprise content sharing App where enterprises pay for the service and the content should never be shared outside the enterprise.","title":"Fault Tolerance - Fault Isolation Terms"},{"location":"level101/systems_design/fault-tolerance/#swimlane-principles","text":"Principle 1: Nothing is shared (also known as \u201cshare as little as possible\u201d). The less that is shared within a swim lane, the more fault isolative the swim lane becomes. (as shown in Enterprise use-case) Principle 2: Nothing crosses a swim lane boundary. Synchronous (defined by expecting a request\u2014not the transfer protocol) communication never crosses a swim lane boundary; if it does, the boundary is drawn incorrectly. (as shown in Ads feature)","title":"Swimlane Principles"},{"location":"level101/systems_design/fault-tolerance/#swimlane-approaches","text":"Approach 1: Swim lane the money-maker. Never allow your cash register to be compromised by other systems. (Tier 1 vs Tier 2 in enterprise use case) Approach 2: Swim lane the biggest sources of incidents. Identify the recurring causes of pain and isolate them. (if Ads feature is in code yellow, swim laning it is the best option) Approach 3: Swim lane natural barriers. Customer boundaries make good swim lanes. (Public vs Enterprise customers)","title":"Swimlane Approaches"},{"location":"level101/systems_design/fault-tolerance/#refer_1","text":"https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch21.html#ch21","title":"Refer"},{"location":"level101/systems_design/fault-tolerance/#applications-in-sre-role","text":"Work with the DC tech or cloud team to distribute infrastructure such that its immune to switch or power failures by creating fault zones within a Data Center https://docs.microsoft.com/en-us/azure/virtual-machines/manage-availability#use-availability-zones-to-protect-from-datacenter-level-failures Work with the partners and design interaction between services such that one service breakdown is not amplified in a cascading fashion to all upstreams","title":"Applications in SRE role"},{"location":"level101/systems_design/intro/","text":"Systems Design Prerequisites Fundamentals of common software system components: Linux Basics Linux Networking Databases RDBMS NoSQL Concepts What to expect from this course Thinking about and designing for scalability, availability, and reliability of large scale software systems. What is not covered under this course Individual software components\u2019 scalability and reliability concerns like e.g. Databases, while the same scalability principles and thinking can be applied, these individual components have their own specific nuances when scaling them and thinking about their reliability. More light will be shed on concepts rather than on setting up and configuring components like Loadbalancers to achieve scalability, availability, and reliability of systems Course Contents Introduction Scalability High Availability Fault Tolerance Introduction So, how do you go about learning to design a system? \u201d Like most great questions, it showed a level of naivety that was breathtaking. The only short answer I could give was, essentially, that you learned how to design a system by designing systems and finding out what works and what doesn\u2019t work.\u201d Jim Waldo, Sun Microsystems, On System Design As software and hardware systems have multiple moving parts, we need to think about how those parts will grow, their failure modes, their inter-dependencies, how it will impact the users and the business. There is no one-shot method or way to learn or do system design, we only learn to design systems by designing and iterating on them. This course will be a starter to make one think about scalability, availability, and fault tolerance during systems design. Backstory Let\u2019s design a simple content sharing application where users can share photos, media in our application which can be liked by their friends. Let\u2019s start with a simple design of the application and evolve it as we learn system design concepts","title":"Introduction"},{"location":"level101/systems_design/intro/#systems-design","text":"","title":"Systems Design"},{"location":"level101/systems_design/intro/#prerequisites","text":"Fundamentals of common software system components: Linux Basics Linux Networking Databases RDBMS NoSQL Concepts","title":"Prerequisites"},{"location":"level101/systems_design/intro/#what-to-expect-from-this-course","text":"Thinking about and designing for scalability, availability, and reliability of large scale software systems.","title":"What to expect from this course"},{"location":"level101/systems_design/intro/#what-is-not-covered-under-this-course","text":"Individual software components\u2019 scalability and reliability concerns like e.g. Databases, while the same scalability principles and thinking can be applied, these individual components have their own specific nuances when scaling them and thinking about their reliability. More light will be shed on concepts rather than on setting up and configuring components like Loadbalancers to achieve scalability, availability, and reliability of systems","title":"What is not covered under this course"},{"location":"level101/systems_design/intro/#course-contents","text":"Introduction Scalability High Availability Fault Tolerance","title":"Course Contents"},{"location":"level101/systems_design/intro/#introduction","text":"So, how do you go about learning to design a system? \u201d Like most great questions, it showed a level of naivety that was breathtaking. The only short answer I could give was, essentially, that you learned how to design a system by designing systems and finding out what works and what doesn\u2019t work.\u201d Jim Waldo, Sun Microsystems, On System Design As software and hardware systems have multiple moving parts, we need to think about how those parts will grow, their failure modes, their inter-dependencies, how it will impact the users and the business. There is no one-shot method or way to learn or do system design, we only learn to design systems by designing and iterating on them. This course will be a starter to make one think about scalability, availability, and fault tolerance during systems design.","title":"Introduction"},{"location":"level101/systems_design/intro/#backstory","text":"Let\u2019s design a simple content sharing application where users can share photos, media in our application which can be liked by their friends. Let\u2019s start with a simple design of the application and evolve it as we learn system design concepts","title":"Backstory"},{"location":"level101/systems_design/scalability/","text":"Scalability What does scalability mean for a system/service? A system is composed of services/components, each service/component scalability needs to be tackled separately, and the scalability of the system as a whole. A service is said to be scalable if, as resources are added to the system, it results in increased performance in a manner proportional to resources added An always-on service is said to be scalable if adding resources to facilitate redundancy does not result in a loss of performance Refer https://www.allthingsdistributed.com/2006/03/a_word_on_scalability.html Scalability - AKF Scale Cube The Scale Cube is a model for segmenting services, defining microservices, and scaling products. It also creates a common language for teams to discuss scale related options in designing solutions. The following section talks about certain scaling patterns based on our inferences from the AKF cube Scalability - Horizontal scaling Horizontal scaling stands for cloning of an application or service such that work can easily be distributed across instances with absolutely no bias. Let's see how our monolithic application improves with this principle Here DB is scaled separately from the application. This is to let you know each component\u2019s scaling capabilities can be different. Usually, web applications can be scaled by adding resources unless there is state stored inside the application. But DBs can be scaled only for Reads by adding more followers but Writes have to go to only one leader to make sure data is consistent. There are some DBs that support multi-leader writes but we are keeping them out of scope at this point. Apps should be able to differentiate between Reads and Writes to choose appropriate DB servers. Load balancers can split traffic between identical servers transparently. WHAT: Duplication of services or databases to spread transaction load. WHEN TO USE: Databases with a very high read-to-write ratio (5:1 or greater\u2014the higher the better). Because only read replicas of DBs can be scaled, not the Leader. HOW TO USE: Simply clone services and implement a load balancer. For databases, ensure that the accessing code understands the difference between a read and a write. WHY: Allows for the fast scale of transactions at the cost of duplicated data and functionality. KEY TAKEAWAYS: This is fast to implement, is a low cost from a developer effort perspective, and can scale transaction volumes nicely. However, they tend to be high cost from the perspective of the operational cost of data. The cost here means if we have 3 followers and 1 Leader DB, the same database will be stored as 4 copies in the 4 servers. Hence added storage cost Refer https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html Scalability Pattern - Load Balancing Improves the distribution of workloads across multiple computing resources, such as computers, a computer cluster, network links, central processing units, or disk drives. A commonly used technique is load balancing traffic across identical server clusters. A similar philosophy is used to load balance traffic across network links by ECMP , disk drives by RAID ,etc Aims to optimize resource use, maximize throughput, minimize response time, and avoid overload of any single resource. Using multiple components with load balancing instead of a single component may increase reliability and availability through redundancy. In our updated architecture diagram we have 4 servers to handle app traffic instead of a single server The device or system that performs load balancing is called a load balancer, abbreviated as LB. Refer https://en.wikipedia.org/wiki/Load_balancing_(computing) https://blog.envoyproxy.io/introduction-to-modern-network-load-balancing-and-proxying-a57f6ff80236 https://learning.oreilly.com/library/view/load-balancing-in/9781492038009/ https://learning.oreilly.com/library/view/practical-load-balancing/9781430236801/ http://shop.oreilly.com/product/9780596000509.do Scalability Pattern - LB Tasks What does an LB do? Service discovery: What backends are available in the system? In our architecture, 4 servers are available to serve App traffic. LB acts as a single endpoint that clients can use transparently to reach one of the 4 servers. Health checking: What backends are currently healthy and available to accept requests? If one out of the 4 App servers turns bad, LB should automatically short circuit the path so that clients don\u2019t sense any application downtime Load balancing: What algorithm should be used to balance individual requests across the healthy backends? There are many algorithms to distribute traffic across one of the four servers. Based on observations/experience, SRE can pick the algorithm that suits their pattern Scalability Pattern - LB Methods Common Load Balancing Methods Least Connection Method directs traffic to the server with the fewest active connections. Most useful when there are a large number of persistent connections in the traffic unevenly distributed between the servers. Works if clients maintain long-lived connections Least Response Time Method directs traffic to the server with the fewest active connections and the lowest average response time. Here response time is used to provide feedback of the server\u2019s health Round Robin Method rotates servers by directing traffic to the first available server and then moves that server to the bottom of the queue. Most useful when servers are of equal specification and there are not many persistent connections. IP Hash the IP address of the client determines which server receives the request. This can sometimes cause skewness in distribution but is useful if apps store some state locally and need some stickiness More advanced client/server-side example techniques - https://docs.nginx.com/nginx/admin-guide/load-balancer/ - http://cbonte.github.io/haproxy-dconv/2.2/intro.html#3.3.5 - https://twitter.github.io/finagle/guide/Clients.html#load-balancing Scalability Pattern - Caching - Content Delivery Networks (CDN) CDNs are added closer to the client\u2019s location. If the app has static data like images, Javascript, CSS which don\u2019t change very often, they can be cached. Since our example is a content sharing site, static content can be cached in CDNs with a suitable expiry. WHAT: Use CDNs (content delivery networks) to offload traffic from your site. WHEN TO USE: When speed improvements and scale warrant the additional cost. HOW TO USE: Most CDNs leverage DNS to serve content on your site\u2019s behalf. Thus you may need to make minor DNS changes or additions and move content to be served from new subdomains. Eg media-exp1.licdn.com is a domain used by Linkedin to serve static content Here a CNAME points the domain to the DNS of the CDN provider dig media-exp1.licdn.com +short 2-01-2c3e-005c.cdx.cedexis.net. WHY: CDNs help offload traffic spikes and are often economical ways to scale parts of a site\u2019s traffic. They also often substantially improve page download times. KEY TAKEAWAYS: CDNs are a fast and simple way to offset the spikiness of traffic as well as traffic growth in general. Make sure you perform a cost-benefit analysis and monitor the CDN usage. If CDNs have a lot of cache misses, then we don\u2019t gain much from CDN and are still serving requests using our compute resources. Scalability - Microservices This pattern represents the separation of work by service or function within the application. Microservices are meant to address the issues associated with growth and complexity in the code base and data sets. The intent is to create fault isolation as well as to reduce response times. Microservices can scale transactions, data sizes, and codebase sizes. They are most effective in scaling the size and complexity of your codebase. They tend to cost a bit more than horizontal scaling because the engineering team needs to rewrite services or, at the very least, disaggregate them from the original monolithic application. WHAT: Sometimes referred to as scale through services or resources, this rule focuses on scaling by splitting data sets, transactions, and engineering teams along verb (services) or noun (resources) boundaries. WHEN TO USE: Very large data sets where relations between data are not necessary. Large, complex systems where scaling engineering resources requires specialization. HOW TO USE: Split up actions by using verbs, or resources by using nouns, or use a mix. Split both the services and the data along the lines defined by the verb/noun approach. WHY: Allows for efficient scaling of not only transactions but also very large data sets associated with those transactions. It also allows for the efficient scaling of teams. KEY TAKEAWAYS: Microservices allow for efficient scaling of transactions, large data sets, and can help with fault isolation. It helps reduce the communication overhead of teams. The codebase becomes less complex as disjoint features are decoupled and spun as new services thereby letting each service scale independently specific to its requirement. Refer https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html Scalability - Sharding This pattern represents the separation of work based on attributes that are looked up to or determined at the time of the transaction. Most often, these are implemented as splits by requestor, customer, or client. Very often, a lookup service or deterministic algorithm will need to be written for these types of splits. Sharding aids in scaling transaction growth, scaling instruction sets, and decreasing processing time (the last by limiting the data necessary to perform any transaction). This is more effective at scaling growth in customers or clients. It can aid with disaster recovery efforts, and limit the impact of incidents to only a specific segment of customers. Here the auth data is sharded based on user names so that DBs can respond faster as the amount of data DBs have to work on has drastically reduced during queries. There can be other ways to split Here the whole data center is split and replicated and clients are directed to a data center based on their geography. This helps in improving performance as clients are directed to the closest data center and performance increases as we add more data centers. There are some replication and consistency overhead with this approach one needs to be aware of. This also gives fault tolerance by rolling out test features to one site and rollback if there is an impact to that geography WHAT: This is very often a split by some unique aspect of the customer such as customer ID, name, geography, and so on. WHEN TO USE: Very large, similar data sets such as large and rapidly growing customer bases or when the response time for a geographically distributed customer base is important. HOW TO USE: Identify something you know about the customer, such as customer ID, last name, geography, or device, and split or partition both data and services based on that attribute. WHY: Rapid customer growth exceeds other forms of data growth, or you have the need to perform fault isolation between certain customer groups as you scale. KEY TAKEAWAYS: Shards are effective at helping you to scale customer bases but can also be applied to other very large data sets that can\u2019t be pulled apart using the microservices methodology. Refer https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html Applications in SRE role SREs in coordination with the network team work on how to map users' traffic to a particular site. https://engineering.linkedin.com/blog/2017/05/trafficshift--load-testing-at-scale SREs work closely with the Dev team to split monoliths to multiple microservices that are easy to run and manage SREs work on improving Load Balancers' reliability, service discovery, and performance SREs work closely to split Data into shards and manage data integrity and consistency. https://engineering.linkedin.com/espresso/introducing-espresso-linkedins-hot-new-distributed-document-store SREs work to set up, configure, and improve the CDN cache hit rate.","title":"Scalability"},{"location":"level101/systems_design/scalability/#scalability","text":"What does scalability mean for a system/service? A system is composed of services/components, each service/component scalability needs to be tackled separately, and the scalability of the system as a whole. A service is said to be scalable if, as resources are added to the system, it results in increased performance in a manner proportional to resources added An always-on service is said to be scalable if adding resources to facilitate redundancy does not result in a loss of performance","title":"Scalability"},{"location":"level101/systems_design/scalability/#refer","text":"https://www.allthingsdistributed.com/2006/03/a_word_on_scalability.html","title":"Refer"},{"location":"level101/systems_design/scalability/#scalability-akf-scale-cube","text":"The Scale Cube is a model for segmenting services, defining microservices, and scaling products. It also creates a common language for teams to discuss scale related options in designing solutions. The following section talks about certain scaling patterns based on our inferences from the AKF cube","title":"Scalability - AKF Scale Cube"},{"location":"level101/systems_design/scalability/#scalability-horizontal-scaling","text":"Horizontal scaling stands for cloning of an application or service such that work can easily be distributed across instances with absolutely no bias. Let's see how our monolithic application improves with this principle Here DB is scaled separately from the application. This is to let you know each component\u2019s scaling capabilities can be different. Usually, web applications can be scaled by adding resources unless there is state stored inside the application. But DBs can be scaled only for Reads by adding more followers but Writes have to go to only one leader to make sure data is consistent. There are some DBs that support multi-leader writes but we are keeping them out of scope at this point. Apps should be able to differentiate between Reads and Writes to choose appropriate DB servers. Load balancers can split traffic between identical servers transparently. WHAT: Duplication of services or databases to spread transaction load. WHEN TO USE: Databases with a very high read-to-write ratio (5:1 or greater\u2014the higher the better). Because only read replicas of DBs can be scaled, not the Leader. HOW TO USE: Simply clone services and implement a load balancer. For databases, ensure that the accessing code understands the difference between a read and a write. WHY: Allows for the fast scale of transactions at the cost of duplicated data and functionality. KEY TAKEAWAYS: This is fast to implement, is a low cost from a developer effort perspective, and can scale transaction volumes nicely. However, they tend to be high cost from the perspective of the operational cost of data. The cost here means if we have 3 followers and 1 Leader DB, the same database will be stored as 4 copies in the 4 servers. Hence added storage cost","title":"Scalability - Horizontal scaling"},{"location":"level101/systems_design/scalability/#refer_1","text":"https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html","title":"Refer"},{"location":"level101/systems_design/scalability/#scalability-pattern-load-balancing","text":"Improves the distribution of workloads across multiple computing resources, such as computers, a computer cluster, network links, central processing units, or disk drives. A commonly used technique is load balancing traffic across identical server clusters. A similar philosophy is used to load balance traffic across network links by ECMP , disk drives by RAID ,etc Aims to optimize resource use, maximize throughput, minimize response time, and avoid overload of any single resource. Using multiple components with load balancing instead of a single component may increase reliability and availability through redundancy. In our updated architecture diagram we have 4 servers to handle app traffic instead of a single server The device or system that performs load balancing is called a load balancer, abbreviated as LB.","title":"Scalability Pattern - Load Balancing"},{"location":"level101/systems_design/scalability/#refer_2","text":"https://en.wikipedia.org/wiki/Load_balancing_(computing) https://blog.envoyproxy.io/introduction-to-modern-network-load-balancing-and-proxying-a57f6ff80236 https://learning.oreilly.com/library/view/load-balancing-in/9781492038009/ https://learning.oreilly.com/library/view/practical-load-balancing/9781430236801/ http://shop.oreilly.com/product/9780596000509.do","title":"Refer"},{"location":"level101/systems_design/scalability/#scalability-pattern-lb-tasks","text":"What does an LB do?","title":"Scalability Pattern - LB Tasks"},{"location":"level101/systems_design/scalability/#service-discovery","text":"What backends are available in the system? In our architecture, 4 servers are available to serve App traffic. LB acts as a single endpoint that clients can use transparently to reach one of the 4 servers.","title":"Service discovery:"},{"location":"level101/systems_design/scalability/#health-checking","text":"What backends are currently healthy and available to accept requests? If one out of the 4 App servers turns bad, LB should automatically short circuit the path so that clients don\u2019t sense any application downtime","title":"Health checking:"},{"location":"level101/systems_design/scalability/#load-balancing","text":"What algorithm should be used to balance individual requests across the healthy backends? There are many algorithms to distribute traffic across one of the four servers. Based on observations/experience, SRE can pick the algorithm that suits their pattern","title":"Load balancing:"},{"location":"level101/systems_design/scalability/#scalability-pattern-lb-methods","text":"Common Load Balancing Methods","title":"Scalability Pattern - LB Methods"},{"location":"level101/systems_design/scalability/#least-connection-method","text":"directs traffic to the server with the fewest active connections. Most useful when there are a large number of persistent connections in the traffic unevenly distributed between the servers. Works if clients maintain long-lived connections","title":"Least Connection Method"},{"location":"level101/systems_design/scalability/#least-response-time-method","text":"directs traffic to the server with the fewest active connections and the lowest average response time. Here response time is used to provide feedback of the server\u2019s health","title":"Least Response Time Method"},{"location":"level101/systems_design/scalability/#round-robin-method","text":"rotates servers by directing traffic to the first available server and then moves that server to the bottom of the queue. Most useful when servers are of equal specification and there are not many persistent connections.","title":"Round Robin Method"},{"location":"level101/systems_design/scalability/#ip-hash","text":"the IP address of the client determines which server receives the request. This can sometimes cause skewness in distribution but is useful if apps store some state locally and need some stickiness More advanced client/server-side example techniques - https://docs.nginx.com/nginx/admin-guide/load-balancer/ - http://cbonte.github.io/haproxy-dconv/2.2/intro.html#3.3.5 - https://twitter.github.io/finagle/guide/Clients.html#load-balancing","title":"IP Hash"},{"location":"level101/systems_design/scalability/#scalability-pattern-caching-content-delivery-networks-cdn","text":"CDNs are added closer to the client\u2019s location. If the app has static data like images, Javascript, CSS which don\u2019t change very often, they can be cached. Since our example is a content sharing site, static content can be cached in CDNs with a suitable expiry. WHAT: Use CDNs (content delivery networks) to offload traffic from your site. WHEN TO USE: When speed improvements and scale warrant the additional cost. HOW TO USE: Most CDNs leverage DNS to serve content on your site\u2019s behalf. Thus you may need to make minor DNS changes or additions and move content to be served from new subdomains. Eg media-exp1.licdn.com is a domain used by Linkedin to serve static content Here a CNAME points the domain to the DNS of the CDN provider dig media-exp1.licdn.com +short 2-01-2c3e-005c.cdx.cedexis.net. WHY: CDNs help offload traffic spikes and are often economical ways to scale parts of a site\u2019s traffic. They also often substantially improve page download times. KEY TAKEAWAYS: CDNs are a fast and simple way to offset the spikiness of traffic as well as traffic growth in general. Make sure you perform a cost-benefit analysis and monitor the CDN usage. If CDNs have a lot of cache misses, then we don\u2019t gain much from CDN and are still serving requests using our compute resources.","title":"Scalability Pattern - Caching - Content Delivery Networks (CDN)"},{"location":"level101/systems_design/scalability/#scalability-microservices","text":"This pattern represents the separation of work by service or function within the application. Microservices are meant to address the issues associated with growth and complexity in the code base and data sets. The intent is to create fault isolation as well as to reduce response times. Microservices can scale transactions, data sizes, and codebase sizes. They are most effective in scaling the size and complexity of your codebase. They tend to cost a bit more than horizontal scaling because the engineering team needs to rewrite services or, at the very least, disaggregate them from the original monolithic application. WHAT: Sometimes referred to as scale through services or resources, this rule focuses on scaling by splitting data sets, transactions, and engineering teams along verb (services) or noun (resources) boundaries. WHEN TO USE: Very large data sets where relations between data are not necessary. Large, complex systems where scaling engineering resources requires specialization. HOW TO USE: Split up actions by using verbs, or resources by using nouns, or use a mix. Split both the services and the data along the lines defined by the verb/noun approach. WHY: Allows for efficient scaling of not only transactions but also very large data sets associated with those transactions. It also allows for the efficient scaling of teams. KEY TAKEAWAYS: Microservices allow for efficient scaling of transactions, large data sets, and can help with fault isolation. It helps reduce the communication overhead of teams. The codebase becomes less complex as disjoint features are decoupled and spun as new services thereby letting each service scale independently specific to its requirement.","title":"Scalability - Microservices"},{"location":"level101/systems_design/scalability/#refer_3","text":"https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html","title":"Refer"},{"location":"level101/systems_design/scalability/#scalability-sharding","text":"This pattern represents the separation of work based on attributes that are looked up to or determined at the time of the transaction. Most often, these are implemented as splits by requestor, customer, or client. Very often, a lookup service or deterministic algorithm will need to be written for these types of splits. Sharding aids in scaling transaction growth, scaling instruction sets, and decreasing processing time (the last by limiting the data necessary to perform any transaction). This is more effective at scaling growth in customers or clients. It can aid with disaster recovery efforts, and limit the impact of incidents to only a specific segment of customers. Here the auth data is sharded based on user names so that DBs can respond faster as the amount of data DBs have to work on has drastically reduced during queries. There can be other ways to split Here the whole data center is split and replicated and clients are directed to a data center based on their geography. This helps in improving performance as clients are directed to the closest data center and performance increases as we add more data centers. There are some replication and consistency overhead with this approach one needs to be aware of. This also gives fault tolerance by rolling out test features to one site and rollback if there is an impact to that geography WHAT: This is very often a split by some unique aspect of the customer such as customer ID, name, geography, and so on. WHEN TO USE: Very large, similar data sets such as large and rapidly growing customer bases or when the response time for a geographically distributed customer base is important. HOW TO USE: Identify something you know about the customer, such as customer ID, last name, geography, or device, and split or partition both data and services based on that attribute. WHY: Rapid customer growth exceeds other forms of data growth, or you have the need to perform fault isolation between certain customer groups as you scale. KEY TAKEAWAYS: Shards are effective at helping you to scale customer bases but can also be applied to other very large data sets that can\u2019t be pulled apart using the microservices methodology.","title":"Scalability - Sharding"},{"location":"level101/systems_design/scalability/#refer_4","text":"https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html","title":"Refer"},{"location":"level101/systems_design/scalability/#applications-in-sre-role","text":"SREs in coordination with the network team work on how to map users' traffic to a particular site. https://engineering.linkedin.com/blog/2017/05/trafficshift--load-testing-at-scale SREs work closely with the Dev team to split monoliths to multiple microservices that are easy to run and manage SREs work on improving Load Balancers' reliability, service discovery, and performance SREs work closely to split Data into shards and manage data integrity and consistency. https://engineering.linkedin.com/espresso/introducing-espresso-linkedins-hot-new-distributed-document-store SREs work to set up, configure, and improve the CDN cache hit rate.","title":"Applications in SRE role"},{"location":"level102/containerization_and_orchestration/conclusion/","text":"Conclusion In this sub-module we have toured the world of containers starting from why we use containers, how containers evolved from the virtual machine past (though they are, in no means, obsolete) and how they are different from virtual machines. We then saw how containers are implemented with emphasis on cgroups and namespaces along with some hands-on exercises. Finally we concluded our journey with container orchestration where we learnt a bit of Kubernetes with some practical examples. Hope this module gives you enough knowledge and interest to continue learning and applying these technologies in greater depth!","title":"Conclusion"},{"location":"level102/containerization_and_orchestration/conclusion/#conclusion","text":"In this sub-module we have toured the world of containers starting from why we use containers, how containers evolved from the virtual machine past (though they are, in no means, obsolete) and how they are different from virtual machines. We then saw how containers are implemented with emphasis on cgroups and namespaces along with some hands-on exercises. Finally we concluded our journey with container orchestration where we learnt a bit of Kubernetes with some practical examples. Hope this module gives you enough knowledge and interest to continue learning and applying these technologies in greater depth!","title":"Conclusion"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/","text":"Introduction Docker has gained huge popularity among other container engines since it was released to the public in 2013. Here are some of the reasons why Docker so popular: Improved portability Docker containers can be shipped and run across environments be it local machine, on-prem or cloud instances in the form of Docker images. Compared to docker containers, LXC containers have more machine specifications. - Lighter weight Docker images are light weight compared to VM images. For example, an Ubuntu 18.04 VM size is about 3GB whereas the docker image is 45MB! Versioning of container images Docker supports maintaining multiple versions of images which makes it easier to look up the history of an image and even rollback. Reuse of images Since Docker images are in the form of layers, one image can be used as base on top of which new images are built. For example, Alpine is a light weight image (5MB) which is commonly used as a base image. Docker layers are managed using storage drivers . Community support Docker hub is a container registry where anyone logged in can upload or download a container image. Docker images of popular OS distros are regularly updated in docker hub and receive large community support. Let\u2019s look at some terms which come up during our discussion of Docker. Docker terminology Docker images Docker image contains the executable version of the application along with the dependencies (config files, libraries, binaries) required for the application to run as a standalone container. It can be understood as a snapshot of a container. Docker images are present as layers on top of the base layer. These layers are the ones that are versioned. The most recent version of layer is the one that is used on top of the base image. docker image ls lists the images present in the host machine. Docker containers Docker container is the running instance of the docker image. While images are static, containers created from the images can be executed into and interacted with. This is actually the \u201ccontainer\u201d from the previous sections of the module. docker run is the command used to instantiate containers from images. docker ps lists docker containers currently running in the host machine. Docker file It is a plain text file of instructions based on which an image is assembled by docker engine (daemon, to be precise). It contains information on base image, ENV variables to be injected. docker build is used to build images from dockerfile. Docker hub It is Docker\u2019s official container registry of images. Any user with a docker login can upload custom images to Docker hub using docker push and fetch images using docker pull . Having known the basic terminologies let\u2019s look at how docker engine works; how CLI commands are interpreted and container life-cycle is managed. Components of Docker engine Let\u2019s start with the diagram of Docker Engine to understand better: The docker engine follows a client-server architecture. It consists of 3 components: Docker client This is the component the user directly interacts with. When you execute docker commands which we saw earlier (push, pull, container ls, image ls) , we are actually using the docker client. A single docker client can communicate with multiple docker daemons. REST API Provides an interface for the docker client and daemon to communicate. Docker Daemon (server) This is the main component of the docker engine. It builds images from dockerfile, fetches images from docker registry, pushes images to the registry, stops, starts containers etc. It also manages networking between containers. LAB The official docker github provides labs at several levels for learning Docker. We're linking one of the labs which we found great for people beginning from scratch. Please follow the labs in this order: Setting up local environment for the labs Basics for using docker CLI Creating and containerizing a basic Flask app Here is another beginner level lab from Katacoda for dockerizing a node js application. You don\u2019t even need a local setup for this and it\u2019s easy to follow along. Advanced features of Docker While we have covered the basics of containerization and how a standalone application can be dockerized, processes in the real world need to communicate with each other. This need is particularly prevalent in applications which follow a microservice architecture. Docker networks Docker networks facilitate the interaction between containers running on the same hosts or even different hosts. There are several options provided through docker network command which specifies how the container interacts with the host and with other containers. The host option allows sharing of network stack with the host, bridge allows communication between containers running on the same host but not external to the host, overlay facilitates interaction between containers across hosts attached to the same network and macvlan which assigns a separate MAC address to a container for legacy containers are some important types of networks supported by Docker. This however is outside the scope of this module. The official documentation on docker networks itself is a good place to start. Volumes Apart from images, containers and networks, Docker also provides the option to create and mount volumes within containers. Generally, data within docker containers is non-persistent i.e once you kill the container the data is lost. Volumes are used for storing persistent data in containers. This KataKoda lab is a great place to start playing with volumes. In the next section we see how container deployments are orchestrated with Kubernetes.","title":"Containerization With Docker"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/#introduction","text":"Docker has gained huge popularity among other container engines since it was released to the public in 2013. Here are some of the reasons why Docker so popular: Improved portability Docker containers can be shipped and run across environments be it local machine, on-prem or cloud instances in the form of Docker images. Compared to docker containers, LXC containers have more machine specifications. - Lighter weight Docker images are light weight compared to VM images. For example, an Ubuntu 18.04 VM size is about 3GB whereas the docker image is 45MB! Versioning of container images Docker supports maintaining multiple versions of images which makes it easier to look up the history of an image and even rollback. Reuse of images Since Docker images are in the form of layers, one image can be used as base on top of which new images are built. For example, Alpine is a light weight image (5MB) which is commonly used as a base image. Docker layers are managed using storage drivers . Community support Docker hub is a container registry where anyone logged in can upload or download a container image. Docker images of popular OS distros are regularly updated in docker hub and receive large community support. Let\u2019s look at some terms which come up during our discussion of Docker.","title":"Introduction"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/#docker-terminology","text":"Docker images Docker image contains the executable version of the application along with the dependencies (config files, libraries, binaries) required for the application to run as a standalone container. It can be understood as a snapshot of a container. Docker images are present as layers on top of the base layer. These layers are the ones that are versioned. The most recent version of layer is the one that is used on top of the base image. docker image ls lists the images present in the host machine. Docker containers Docker container is the running instance of the docker image. While images are static, containers created from the images can be executed into and interacted with. This is actually the \u201ccontainer\u201d from the previous sections of the module. docker run is the command used to instantiate containers from images. docker ps lists docker containers currently running in the host machine. Docker file It is a plain text file of instructions based on which an image is assembled by docker engine (daemon, to be precise). It contains information on base image, ENV variables to be injected. docker build is used to build images from dockerfile. Docker hub It is Docker\u2019s official container registry of images. Any user with a docker login can upload custom images to Docker hub using docker push and fetch images using docker pull . Having known the basic terminologies let\u2019s look at how docker engine works; how CLI commands are interpreted and container life-cycle is managed.","title":"Docker terminology"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/#components-of-docker-engine","text":"Let\u2019s start with the diagram of Docker Engine to understand better: The docker engine follows a client-server architecture. It consists of 3 components: Docker client This is the component the user directly interacts with. When you execute docker commands which we saw earlier (push, pull, container ls, image ls) , we are actually using the docker client. A single docker client can communicate with multiple docker daemons. REST API Provides an interface for the docker client and daemon to communicate. Docker Daemon (server) This is the main component of the docker engine. It builds images from dockerfile, fetches images from docker registry, pushes images to the registry, stops, starts containers etc. It also manages networking between containers.","title":"Components of Docker engine"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/#lab","text":"The official docker github provides labs at several levels for learning Docker. We're linking one of the labs which we found great for people beginning from scratch. Please follow the labs in this order: Setting up local environment for the labs Basics for using docker CLI Creating and containerizing a basic Flask app Here is another beginner level lab from Katacoda for dockerizing a node js application. You don\u2019t even need a local setup for this and it\u2019s easy to follow along.","title":"LAB"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/#advanced-features-of-docker","text":"While we have covered the basics of containerization and how a standalone application can be dockerized, processes in the real world need to communicate with each other. This need is particularly prevalent in applications which follow a microservice architecture. Docker networks Docker networks facilitate the interaction between containers running on the same hosts or even different hosts. There are several options provided through docker network command which specifies how the container interacts with the host and with other containers. The host option allows sharing of network stack with the host, bridge allows communication between containers running on the same host but not external to the host, overlay facilitates interaction between containers across hosts attached to the same network and macvlan which assigns a separate MAC address to a container for legacy containers are some important types of networks supported by Docker. This however is outside the scope of this module. The official documentation on docker networks itself is a good place to start. Volumes Apart from images, containers and networks, Docker also provides the option to create and mount volumes within containers. Generally, data within docker containers is non-persistent i.e once you kill the container the data is lost. Volumes are used for storing persistent data in containers. This KataKoda lab is a great place to start playing with volumes. In the next section we see how container deployments are orchestrated with Kubernetes.","title":"Advanced features of Docker"},{"location":"level102/containerization_and_orchestration/intro/","text":"Containers and orchestration Introduction Containers, Docker and Kubernetes are \"cool\" terms that are being spoken of by everyone involved with software in some way. Let's dive into each of these pieces of technology at enough depth to understand what the whole deal is about! In this module we talk about the ins and outs of containers: the internals and usage of containers; how they are implemented, how to containerize your application and finally, how to deploy containerized applications on a large scale without losing your sleep. We'll also get our hands dirty by trying out a few lab exercises. Prerequisites Basic knowledge of linux will be helpful understanding the internals of containers Basic knowledge of shell commands (will come handy when we're containerizing applications) Knowledge of running a basic web application. You can go through our Python And Web module to gain familiarity with this. What to expect from this course This module is divided into 3 sub-modules. In the first sub module, we will cover the internals of containerization and why they\u2019re used for. The second sub-module introduces Docker, a popular container engine and contains lab exercises on dockerizing a basic webapp. The last module talks about container orchestration with Kubernetes and some lab exercises to show how it makes the lives of SREs easy. What is not covered under this course We will not cover advanced docker and kubernetes concepts. However, we will be leading you to links and references from where you can pick them up as per your interest. Course Contents The following topics has been covered in this course: Introduction to containers What are containers Why containers Difference between virtual machines and containers How are containers implemented Namespaces Cgroups Container engines Containerization with Docker Introduction Basic docker terminology Components of Docker engine Hands-on Introduction to Advanced Docker Container orchestration with Kubernetes Introduction Motivation to use Kubernetes Kubernetes Architecture Hands-on Introduction to Advanced Kubernetes concepts Conclusion","title":"Introduction"},{"location":"level102/containerization_and_orchestration/intro/#containers-and-orchestration","text":"","title":"Containers and orchestration"},{"location":"level102/containerization_and_orchestration/intro/#introduction","text":"Containers, Docker and Kubernetes are \"cool\" terms that are being spoken of by everyone involved with software in some way. Let's dive into each of these pieces of technology at enough depth to understand what the whole deal is about! In this module we talk about the ins and outs of containers: the internals and usage of containers; how they are implemented, how to containerize your application and finally, how to deploy containerized applications on a large scale without losing your sleep. We'll also get our hands dirty by trying out a few lab exercises.","title":"Introduction"},{"location":"level102/containerization_and_orchestration/intro/#prerequisites","text":"Basic knowledge of linux will be helpful understanding the internals of containers Basic knowledge of shell commands (will come handy when we're containerizing applications) Knowledge of running a basic web application. You can go through our Python And Web module to gain familiarity with this.","title":"Prerequisites"},{"location":"level102/containerization_and_orchestration/intro/#what-to-expect-from-this-course","text":"This module is divided into 3 sub-modules. In the first sub module, we will cover the internals of containerization and why they\u2019re used for. The second sub-module introduces Docker, a popular container engine and contains lab exercises on dockerizing a basic webapp. The last module talks about container orchestration with Kubernetes and some lab exercises to show how it makes the lives of SREs easy.","title":"What to expect from this course"},{"location":"level102/containerization_and_orchestration/intro/#what-is-not-covered-under-this-course","text":"We will not cover advanced docker and kubernetes concepts. However, we will be leading you to links and references from where you can pick them up as per your interest.","title":"What is not covered under this course"},{"location":"level102/containerization_and_orchestration/intro/#course-contents","text":"The following topics has been covered in this course: Introduction to containers What are containers Why containers Difference between virtual machines and containers How are containers implemented Namespaces Cgroups Container engines Containerization with Docker Introduction Basic docker terminology Components of Docker engine Hands-on Introduction to Advanced Docker Container orchestration with Kubernetes Introduction Motivation to use Kubernetes Kubernetes Architecture Hands-on Introduction to Advanced Kubernetes concepts Conclusion","title":"Course Contents"},{"location":"level102/containerization_and_orchestration/intro_to_containers/","text":"What are containers Here's a popular definition of containers according to Docker , a popular containerization engine : A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another Let's break this down. A container is your code bundled along with its entire runtime environment. That includes your system libraries, binaries and config files needed for your application to run. Why containers You might wonder why we need to pack your application along with its dependencies. This is where the second part of the definition comes, ...so the application runs quickly and reliably from one computing environment to another. Developers usually write code in their dev environment (or local machine), test it in one or two staging/test environments before pushing their code into production. Ideally, for reliably testing applications before pushing to production, we need all these environments to be uniform to a tee (underlying OS, system libraries etc). Of course, the ideal is hard to achieve especially when we're using a mix of on-prem (complete control) and cloud infrastructure providers (more restrictive in terms of control of hardware and security options), a scenario which is more common today. This is exactly why we need to package not only the code but also the dependencies; so that your application runs reliably irrespective of which infrastructure or environment it runs on. We can run several containers on a single host. Due to how containers are implemented, each container has its own isolated environment within the same host. This means that a monolithic application can be broken down into micro-services and packaged into containers. Each microservice runs in the host machine in isolated environments. This is another reason why containers are used: separation of concerns . Providing isolated environments does not let the failure of one application in one container affect the other. This is called fault isolation . Isolation also gives the added benefit of increased security due to restricted visibility of processes in a container. Due to how most of the containerization solutions are implemented, we also have the option to cap the amount of resources consumed by applications running within a container. This is called resource limiting . Will will discuss this feature in more detail in the section on cgroups. Difference between virtual machines and containers Let's digress a little and go into some history. In the previous section we talked about how containers help us in achieving separation of concerns. Before the wide-spread usage of containers, virtualization was used for running applications in isolated environments in the same host (it\u2019s still being used today in some cases). In plain terms, virtualization is where we package software along with a copy of the OS on which it runs. This package is called a virtual machine (VM). The image of the OS bundled in the VM is called Guest OS. A component called Hypervisor sits between the Guest and the Host OS and is responsible for facilitating the access of the underlying OS\u2019s hardware to the Guest OS. You can learn more about hypervisors here . Similar to how multiple containers can be run in a single host machine, multiple VMs can be run on a single host and in this way, it\u2019s possible to run applications (or each microservice) in a separate VM and achieve separation of concerns. The main focus here is on the size of the VMs and containers. VMs come along with a copy of the guest operating system and therefore are heavy-weight compared to containers. If you\u2019re more interested in comparison of VMs and containers, you can check these articles from Backblaze and NetApp . While it is possible to run an operating system on a host with an incompatible kernel using hypervisors (e.g Windows 10 VM on CentOS 7), in cases where kernels can be shared (e.g Ubuntu on CentOS 7) containers are preferred over VMs due to the size factor. Sharing kernels, as you will see later, also gives containers many performance benefits over VMs like quicker boot-ups. Let\u2019s look at the diagram of how containers work. Comparing the two diagrams, we notice two things: Containers do not have a separate (guest) OS Container engine is the intermediary between containers and Host OS. It is used to facilitate the life-cycle of a container on the Host OS (it is not a necessity, however). The next section explains in detail how containers share the same operating system (kernel, to be precise) as the host machine and yet provide isolated environments for applications to run. How are containers implemented We\u2019ve talked about how containers, unlike virtual machines, share the same kernel as the host operating system and provide isolated environments for applications to run. This is achieved without the overhead of running a guest operating system on the host OS, thanks to two features of linux kernel called cgroups and kernel namespaces. Now that we are touching upon the internals of containers, it would be appropriate to give a more technically accurate representation of what they are. A container is a linux process or a group of linux processes which is restricted in - visibility into processes outside the container (implemented using namespace) - quantity of resources it can use (implemented using cgroups) and - system calls that can be made from the container. Refer seccomp , if interested in knowing more. These restrictions are what make a containerized application remain isolated from other processes running in the same host. Now let\u2019s talk about namespaces and cgroup in a little more detail. Namespaces Visibility of processes inside a container should be restricted within itself. This is what linux namespaces do. The idea is that processes within a namespace can\u2019t affect those which it can\u2019t \u201csee\u201d. Processes sharing a single namespace have identities, service and/or interfaces unique to the namespace they exist in. Here\u2019s a list of namespaces in linux: Mount Process groups sharing a mount namespace share a separate, private set of mount points and file system view. Any modifications made to these namespaced mount points are not visible outside the namespace. For example it is possible to have a /var within the a mount namespace which is different from /var in the host. PID A processes in a pid namespace have process ids which are unique only within the namespace. A process can be a root process (pid 1) in its own pid namespace and have an entire tree of processes under it. Network Each network namespace will have its own network device instances that can be configured with individual network addresses. Processes in the same network namespace can have their own ports and route tables. User User namespaces can have their own users and group ids. It\u2019s possible for a process using a non-privileged user in the host machine to have a root user identity within a user namespace. Cgroup Allows creation of cgroups which can be used only within the cgroup namespace. Cgroups will be covered in more detail in the following section. UTS This namespace has its own hostname and domain name IPC. Each IPC namespace has its own System V and POSIX message queues. As complex as it seems, creating namespaces in linux is quite simple. Let\u2019s see a quick demo to create a PID namespace. You\u2019ll need a linux based OS with sudoers permission to follow along. DEMO: namespaces First we check which processes are running in the host system (output varies from system to system). Note the process with pid 1. Let\u2019s create a PID namespace with the unshare command and create a bash process in the namespace You can see that ps aux (which itself is a process launched in the PID namespace so created) can only see processes within its own namespace. Hence, the output shows only 2 processes running within the namespace. Also note, the root process (pid 1) in the namespace is not init but it is the bash shell which we specified while creating the namespace. Let\u2019s create another process in the same namespace which sleeps for 1000 seconds in the background. In my case the pid of the sleep process is 44 within the PID namespace . On a separate terminal, check for the process id of the sleep process as seen from the host. Note the difference in pid (23844 in the host and 44 within the namespace) though both refer to the same process (start time and all other attributes are same). It\u2019s also possible to nest namespaces i.e create a pid namespace from another pid namespace. Try out sudo nsenter -t 23844 --pid -r bash to reenter the namespace and create another pid namespace within it. It should be fun to do! Cgroups A cgroup can be defined as a set of processes whose usage of resources is metered and monitored. The resources can be memory pages, disk i/o, CPU etc. In fact, cgroups are classified based on which resource the limit is imposed on and nature of action taken when a limit is violated. The component in the cgroup which tracks resource utilization and controls the behaviour of processes in a cgroup is called resource-subsystem or resource controller. Following is the set of resource controllers and their function according to RHEL\u2019s introduction to cgroups : blkio \u2014 this subsystem sets limits on input/output access to and from block devices such as physical drives (disk, solid state, or USB). cpu \u2014 this subsystem uses the scheduler to provide cgroup processes access to the CPU. cpuacct \u2014 this subsystem generates automatic reports on CPU resources used by processes in a cgroup. cpuset \u2014 this subsystem assigns individual CPUs (on a multicore system) and memory nodes to processes in a cgroup. devices \u2014 this subsystem allows or denies access to devices by processes in a cgroup. freezer \u2014 this subsystem suspends or resumes processes in a cgroup. memory \u2014 this subsystem sets limits on memory use by processes in a cgroup and generates automatic reports on memory resources used by those processes. Cgroups follow a hierarchical, tree-like structure for each resource controller i.e one cgroup exists for each controller. Each cgroup in a hierarchy inherits certain attributes (e.g limits) from its parent cgroup. Let\u2019s try out a quick demo with memory cgroups to wrap our heads around the above ideas. You\u2019ll need a linux based OS (here, RedHat) with sudo permission to follow along. DEMO: cgroups Let\u2019s start by checking if cgroup tools are installed in your machine. Execute mount | grep \"^cgroup\" . If you have the tools installed you\u2019ll see a output like this: If not, install the tools with sudo yum install libcgroup-tools -y . Now, we create a memory cgroup called mem_group with \u201croot\u201d as the owner of the cgroup. Command executed sudo cgcreate -a root -g memory:mem_group . Verify that cgroup is created. /sys/fs/cgroup/ is the pseudo filesystem where a newly created cgroup is added as a sub-group. Memory cgroup puts a limit on the memory usage of processes in the cgroup. Let\u2019s see what the limits are for mem_group. The file for checking the memory limit is memory.limit_in_bytes( more information here , if you\u2019re interested). Note that mem_group has inherited the limit from its parent cgroup Now, let\u2019s reduce the memory usage limit to 20KB for the purpose of our demo (the actual limit is rounded off to the nearest power of 2). This limit is too low and hence most of the processes attached to mem_group should be OOM killed. Create a new shell and attach it to the cgroup. We need sudo permissions for this. The process is OOM killed as expected. You can confirm the same with dmesg logs (mm_fault_error). If you want to try out a more in-depth exercise on cgroups, check out this tutorial from Geeks for Geeks . Let\u2019s come back to containers again. Containers share the same kernel as the underlying host operating system and provide an isolated environment of the application within. Cgroups help in managing resources used by processes within a container and namespaces help isolate network stack, pids, users, group ids and mount points in a container from another container running on the same host. Of course, there are more components to containers which truly make it fully functional but that discussion is out of scope of this module. Container engine Container engines ease the process of creating and managing containers in a host machine. How? The container creation workflow typically begins with a container image. A container image is a packaged, portable version of the target application bundled with all dependencies for it to run. These container images are either available on the host machine (container host) from previous builds or need to be pulled from a remote repository of images. Sometimes the container engine might need to build the container image from a set of instructions. Finally once the container image is fetched/built, the container engine unpacks the image and creates an isolated environment for the application as per the image specifications. The files in the container image are then mounted to the isolated environment to get the application up and running within the container. There are several container engines available like Docker, RKT, LXC (one of the first container engines) which require different image formats (Docker, LXD). OCI (Open Container Initiative) is a collaborative project started by Docker that aims to standardize container runtime specifications and image formats across vendors. OCI FAQ section is a good place to start if you\u2019re curious about this project. We will focus on Docker in the next section .","title":"Introduction To Containers"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#what-are-containers","text":"Here's a popular definition of containers according to Docker , a popular containerization engine : A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another Let's break this down. A container is your code bundled along with its entire runtime environment. That includes your system libraries, binaries and config files needed for your application to run.","title":"What are containers"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#why-containers","text":"You might wonder why we need to pack your application along with its dependencies. This is where the second part of the definition comes, ...so the application runs quickly and reliably from one computing environment to another. Developers usually write code in their dev environment (or local machine), test it in one or two staging/test environments before pushing their code into production. Ideally, for reliably testing applications before pushing to production, we need all these environments to be uniform to a tee (underlying OS, system libraries etc). Of course, the ideal is hard to achieve especially when we're using a mix of on-prem (complete control) and cloud infrastructure providers (more restrictive in terms of control of hardware and security options), a scenario which is more common today. This is exactly why we need to package not only the code but also the dependencies; so that your application runs reliably irrespective of which infrastructure or environment it runs on. We can run several containers on a single host. Due to how containers are implemented, each container has its own isolated environment within the same host. This means that a monolithic application can be broken down into micro-services and packaged into containers. Each microservice runs in the host machine in isolated environments. This is another reason why containers are used: separation of concerns . Providing isolated environments does not let the failure of one application in one container affect the other. This is called fault isolation . Isolation also gives the added benefit of increased security due to restricted visibility of processes in a container. Due to how most of the containerization solutions are implemented, we also have the option to cap the amount of resources consumed by applications running within a container. This is called resource limiting . Will will discuss this feature in more detail in the section on cgroups.","title":"Why containers"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#difference-between-virtual-machines-and-containers","text":"Let's digress a little and go into some history. In the previous section we talked about how containers help us in achieving separation of concerns. Before the wide-spread usage of containers, virtualization was used for running applications in isolated environments in the same host (it\u2019s still being used today in some cases). In plain terms, virtualization is where we package software along with a copy of the OS on which it runs. This package is called a virtual machine (VM). The image of the OS bundled in the VM is called Guest OS. A component called Hypervisor sits between the Guest and the Host OS and is responsible for facilitating the access of the underlying OS\u2019s hardware to the Guest OS. You can learn more about hypervisors here . Similar to how multiple containers can be run in a single host machine, multiple VMs can be run on a single host and in this way, it\u2019s possible to run applications (or each microservice) in a separate VM and achieve separation of concerns. The main focus here is on the size of the VMs and containers. VMs come along with a copy of the guest operating system and therefore are heavy-weight compared to containers. If you\u2019re more interested in comparison of VMs and containers, you can check these articles from Backblaze and NetApp . While it is possible to run an operating system on a host with an incompatible kernel using hypervisors (e.g Windows 10 VM on CentOS 7), in cases where kernels can be shared (e.g Ubuntu on CentOS 7) containers are preferred over VMs due to the size factor. Sharing kernels, as you will see later, also gives containers many performance benefits over VMs like quicker boot-ups. Let\u2019s look at the diagram of how containers work. Comparing the two diagrams, we notice two things: Containers do not have a separate (guest) OS Container engine is the intermediary between containers and Host OS. It is used to facilitate the life-cycle of a container on the Host OS (it is not a necessity, however). The next section explains in detail how containers share the same operating system (kernel, to be precise) as the host machine and yet provide isolated environments for applications to run.","title":"Difference between virtual machines and containers"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#how-are-containers-implemented","text":"We\u2019ve talked about how containers, unlike virtual machines, share the same kernel as the host operating system and provide isolated environments for applications to run. This is achieved without the overhead of running a guest operating system on the host OS, thanks to two features of linux kernel called cgroups and kernel namespaces. Now that we are touching upon the internals of containers, it would be appropriate to give a more technically accurate representation of what they are. A container is a linux process or a group of linux processes which is restricted in - visibility into processes outside the container (implemented using namespace) - quantity of resources it can use (implemented using cgroups) and - system calls that can be made from the container. Refer seccomp , if interested in knowing more. These restrictions are what make a containerized application remain isolated from other processes running in the same host. Now let\u2019s talk about namespaces and cgroup in a little more detail.","title":"How are containers implemented"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#namespaces","text":"Visibility of processes inside a container should be restricted within itself. This is what linux namespaces do. The idea is that processes within a namespace can\u2019t affect those which it can\u2019t \u201csee\u201d. Processes sharing a single namespace have identities, service and/or interfaces unique to the namespace they exist in. Here\u2019s a list of namespaces in linux: Mount Process groups sharing a mount namespace share a separate, private set of mount points and file system view. Any modifications made to these namespaced mount points are not visible outside the namespace. For example it is possible to have a /var within the a mount namespace which is different from /var in the host. PID A processes in a pid namespace have process ids which are unique only within the namespace. A process can be a root process (pid 1) in its own pid namespace and have an entire tree of processes under it. Network Each network namespace will have its own network device instances that can be configured with individual network addresses. Processes in the same network namespace can have their own ports and route tables. User User namespaces can have their own users and group ids. It\u2019s possible for a process using a non-privileged user in the host machine to have a root user identity within a user namespace. Cgroup Allows creation of cgroups which can be used only within the cgroup namespace. Cgroups will be covered in more detail in the following section. UTS This namespace has its own hostname and domain name IPC. Each IPC namespace has its own System V and POSIX message queues. As complex as it seems, creating namespaces in linux is quite simple. Let\u2019s see a quick demo to create a PID namespace. You\u2019ll need a linux based OS with sudoers permission to follow along.","title":"Namespaces"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#demo-namespaces","text":"First we check which processes are running in the host system (output varies from system to system). Note the process with pid 1. Let\u2019s create a PID namespace with the unshare command and create a bash process in the namespace You can see that ps aux (which itself is a process launched in the PID namespace so created) can only see processes within its own namespace. Hence, the output shows only 2 processes running within the namespace. Also note, the root process (pid 1) in the namespace is not init but it is the bash shell which we specified while creating the namespace. Let\u2019s create another process in the same namespace which sleeps for 1000 seconds in the background. In my case the pid of the sleep process is 44 within the PID namespace . On a separate terminal, check for the process id of the sleep process as seen from the host. Note the difference in pid (23844 in the host and 44 within the namespace) though both refer to the same process (start time and all other attributes are same). It\u2019s also possible to nest namespaces i.e create a pid namespace from another pid namespace. Try out sudo nsenter -t 23844 --pid -r bash to reenter the namespace and create another pid namespace within it. It should be fun to do!","title":"DEMO: namespaces"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#cgroups","text":"A cgroup can be defined as a set of processes whose usage of resources is metered and monitored. The resources can be memory pages, disk i/o, CPU etc. In fact, cgroups are classified based on which resource the limit is imposed on and nature of action taken when a limit is violated. The component in the cgroup which tracks resource utilization and controls the behaviour of processes in a cgroup is called resource-subsystem or resource controller. Following is the set of resource controllers and their function according to RHEL\u2019s introduction to cgroups : blkio \u2014 this subsystem sets limits on input/output access to and from block devices such as physical drives (disk, solid state, or USB). cpu \u2014 this subsystem uses the scheduler to provide cgroup processes access to the CPU. cpuacct \u2014 this subsystem generates automatic reports on CPU resources used by processes in a cgroup. cpuset \u2014 this subsystem assigns individual CPUs (on a multicore system) and memory nodes to processes in a cgroup. devices \u2014 this subsystem allows or denies access to devices by processes in a cgroup. freezer \u2014 this subsystem suspends or resumes processes in a cgroup. memory \u2014 this subsystem sets limits on memory use by processes in a cgroup and generates automatic reports on memory resources used by those processes. Cgroups follow a hierarchical, tree-like structure for each resource controller i.e one cgroup exists for each controller. Each cgroup in a hierarchy inherits certain attributes (e.g limits) from its parent cgroup. Let\u2019s try out a quick demo with memory cgroups to wrap our heads around the above ideas. You\u2019ll need a linux based OS (here, RedHat) with sudo permission to follow along.","title":"Cgroups"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#demo-cgroups","text":"Let\u2019s start by checking if cgroup tools are installed in your machine. Execute mount | grep \"^cgroup\" . If you have the tools installed you\u2019ll see a output like this: If not, install the tools with sudo yum install libcgroup-tools -y . Now, we create a memory cgroup called mem_group with \u201croot\u201d as the owner of the cgroup. Command executed sudo cgcreate -a root -g memory:mem_group . Verify that cgroup is created. /sys/fs/cgroup/ is the pseudo filesystem where a newly created cgroup is added as a sub-group. Memory cgroup puts a limit on the memory usage of processes in the cgroup. Let\u2019s see what the limits are for mem_group. The file for checking the memory limit is memory.limit_in_bytes( more information here , if you\u2019re interested). Note that mem_group has inherited the limit from its parent cgroup Now, let\u2019s reduce the memory usage limit to 20KB for the purpose of our demo (the actual limit is rounded off to the nearest power of 2). This limit is too low and hence most of the processes attached to mem_group should be OOM killed. Create a new shell and attach it to the cgroup. We need sudo permissions for this. The process is OOM killed as expected. You can confirm the same with dmesg logs (mm_fault_error). If you want to try out a more in-depth exercise on cgroups, check out this tutorial from Geeks for Geeks . Let\u2019s come back to containers again. Containers share the same kernel as the underlying host operating system and provide an isolated environment of the application within. Cgroups help in managing resources used by processes within a container and namespaces help isolate network stack, pids, users, group ids and mount points in a container from another container running on the same host. Of course, there are more components to containers which truly make it fully functional but that discussion is out of scope of this module.","title":"DEMO: cgroups"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#container-engine","text":"Container engines ease the process of creating and managing containers in a host machine. How? The container creation workflow typically begins with a container image. A container image is a packaged, portable version of the target application bundled with all dependencies for it to run. These container images are either available on the host machine (container host) from previous builds or need to be pulled from a remote repository of images. Sometimes the container engine might need to build the container image from a set of instructions. Finally once the container image is fetched/built, the container engine unpacks the image and creates an isolated environment for the application as per the image specifications. The files in the container image are then mounted to the isolated environment to get the application up and running within the container. There are several container engines available like Docker, RKT, LXC (one of the first container engines) which require different image formats (Docker, LXD). OCI (Open Container Initiative) is a collaborative project started by Docker that aims to standardize container runtime specifications and image formats across vendors. OCI FAQ section is a good place to start if you\u2019re curious about this project. We will focus on Docker in the next section .","title":"Container engine"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/","text":"Introduction Now we finally arrive at the most awaited part: running and managing containers at scale. So far, we have seen how Docker facilitates managing the life-cycle of containers and provides improved portability of applications. Docker does provide a solution for easing the deployment of containers on a large scale ( you can check out Docker Swarm, if interested) which integrates well with Docker containers. However, Kubernetes has become the de-facto tool for orchestrating the management of microservices (as containers) in large distributed environments. Let\u2019s see the points of interest for us, SREs, to use container orchestration tools and Kubernetes in particular. Motivation to use Kubernetes Ease of usage Though there is a steep learning curve associated with Kubernetes, once learnt , can be used as a one stop tool to manage your microservices. With a single command it is possible to deploy full fledged production ready environments. The desired state of an application needs to be recorded as a YAML manifest and Kubernetes manages the application for you. Ensure optimum usage of resources We can specify limits on resources used by each container in a deployment. We can also specify our choice of nodes where Kubernetes can schedule nodes to be deployed (e.g microservices with high CPU consumption can be instructed to be deployed in high compute nodes). Fault tolerance Self-healing is built into basic resource types of Kubernetes. This removes the headache of designing a fault tolerant application system from scratch. This applies especially to stateless applications. Infrastructure agnostic Kubernetes does not have vendor lock-in. It can be set up in multiple cloud environments or in on-prem data centers. Strong community support and documentation Kubernetes is open-source and many technologies like operators, service mesh etc. have been built by the community to manage and monitor Kubernetes-orchestrated applications better. Extensible and customisable We can build our custom resource definitions which fit our use case for managing applications and use Kubernetes to manage them (with custom controllers). You can check out this article if you are more interested in this topic. Architecture of Kubernetes Here\u2019s a diagram (from the official Kubernetes documentation ) containing different components which make Kubernetes work: Kubernetes components can be divided into two parts: control plane components and data plane components . A Kubernetes cluster consists of 1 or more host machines (called nodes) where the containers managed by Kubernetes are run. This constitutes the data plane (or node plane). The brain of Kuberentes which responds to events from the node plane (e.g create a pod, replicas mismatch) and does the main orchestration is called the control plane. All control plane components are typically installed in a master node. This master node does not run any user containers. The Kubernetes components themselves are run as containers wrapped in Pods (which is the most basic kubernetes resource object). Control plane components: kube-apiserver etcd kube-scheduler kube-controller-manager Node plane components kubelet kube-proxy This workflow might help you understand the working on components better: An SRE installs kubectl in their local machine. This is the client which interacts with the Kubernetes control plane (and hence the cluster). They create a YAML file, called manifest which specifies the desired state of the resource (e.g a deployment names \u201cfrontend\u201d needs 3 pods to always be running) When they issue a command to create objects based in the YAML file, the kubectl CLI tool sends a rest API request to the kube-apiserver . If the manifest is valid, it is stored as key value pairs in the etcd server on the control plane. kube-scheduler chooses which nodes to put the containers on (basically schedules them) There are controller processes (managed by kube-controller manager) which makes sure the current state of the cluster is equivalent to the desired state (here, 3 pods are indeed running in the cluster -> all is fine). On the node plane side, kubelet makes sure that pods are locally kept in running state. LAB Prerequisites The best way to start this exercise is to use a Katacoda kubernetes playground . A single node kubernetes cluster is already set up for you here for quick experimentation. You can also use this to play with docker. The environment gets torn down after 10 mins. So make sure that you save your files if you want to resume them. For persistent kubernetes clusters, you can set it up either in your local (using minikube ) or you can create a kubernetes cluster in Azure , GCP or any other cloud provider. Knowledge of YAML is nice to have for understanding the manifest files. Hands-on Lab 1: We are going to create an object called Pod which is the most basic unit for running a container in Kubernetes. Here, we will create a pod called \u2018nginx-pod\u201d which contains an nginx container called \u201cweb\u201d. We will also expose port 80 in the container so that we can interact with the nginx container. Save the below manifest in a file called nginx-pod.yaml apiVersion: v1 #[1] kind: Pod #[2] metadata: #[3] name: nginx-pod #[4] labels: #[5] app: nginx spec: #[6] containers: #[7] - name: web #[8] image: nginx #[9] ports: #[10] - name: web #[11] containerPort: 80 #[12] protocol: TCP #[13] Let\u2019s very briefly understand what\u2019s here: #[2] - kind: The \u201ckind\u201d of object that\u2019s being created. Here it is a Pod #[1] - apiVersion: The apiVersion of the \u201cPod\u201d resource. There could be minor changes in the values or keys in the yaml file if the version varies. #[3] - metadata: The metadata section of the file where pod labels and name is given #[6] - spec: This is the main part where the things inside the pod are defined These are not random key value pairs! They have to be interpretable by the kubeapiserver. You can check which key value pairs are optional/mandatory using kubectl explain pod command. Do try it out! Apply the manifest using the command kubectl apply -f nginx-pod.yaml . This creates the \u201cnginx-pod\u201d pod in the kubernetes cluster. Verify that the pod is in running state using kubectl get pod . It shows that nginx-pod is in Running state. 1/1 indicates that out of 1 out of 1 container(s) inside the pod is healthy. To check if the container running in \u201cnginx-pod\u201d is indeed \u201cweb\u201d we do the kubectl describe pod/nginx-pod command. This gives a lengthy output with a detailed description of the pod and the events that happened since the pod was created. This command is very useful for debugging. The part we are concerned here is this: You can see \u201cweb\u201d under the Containers section with Image as nginx. This is what we are looking for. How do we access the welcome page of nginx \u201cweb\u201d container? In the describe command you can see the IP address of the pod. Each pod is assigned an IP address on creation. Here, this is 10.244.1.3 Issue a curl request from the host curl 10.244.1.3:80 . You will get the welcome page! Let\u2019s say we want to use a specific tag of nginx (say 1.20.1) in the same pod i.e we want to modify some property of the pod. You can try editing nginx-pod.yaml (image: nginx:1.20.1 in #[9])and reapplying (step 2.). It will create a new container in the same pod with the new image. A container is created within the pod but the pod is the same. You can verify by checking the pod start time in describe command. It would show a much older time. You can actually see the nginx container by doing docker ps on the node01 terminal (if you\u2019re using Katacoda). What if we want to change the image to 1.20.1 for 1000 nginx pods? Stepping a little back, what if we want to create 1000 nginx pods. Of course, we can write a script but Kubernetes already offers a resource type called \u201cdeployment\u201d to manage large scale deployments better. Lab 2: We\u2019ll go a step further to see how we can create more than a single instance of the nginx pod at the same time. We will first create Save the below manifest in a file called nginx-deploy.yaml apiVersion: apps/v1 kind: Deployment #[1] metadata: name: nginx-deployment labels: app: nginx spec: replicas: 3 #[2] selector: matchLabels: app: nginx #[3] template: #[4] metadata: labels: app: nginx #[5] spec: containers: - name: web image: nginx ports: - name: web containerPort: 80 protocol: \"TCP\" You can see that it is similar to a pod definition till spec ( #[1] has Deployment as kind, api version is also different). Another thing interesting observation is the metadata and spec parts under #[4] is almost the same as the metadata and spec section under the Pod definition in Lab 1 (do go up and cross check this). What this implies is that we are deploying 3 nginx pods similar to Lab1. Also, the labels in matchLabels should be the same as labels under #[4] . Now apply the manifest using kubectl apply -f nginx-deploy.yaml Verify that 3 pods are indeed created. If you\u2019re curious, check the output of kubectl get deploy and kubectl describe deploy nginx-deployment . Delete one of the 3 pods using kubectl delete pod . After a few seconds again do kubectl get pod . You can see that a new pod is spawned to keep the total number of pods as 3 (see AGE 15s compared to others created 27 minutes ago)! This is a demonstration of how Kubernetes does fault tolerance. This is a property of Kubernetes deployment object (kill the pod from Lab1, it won\u2019t be respawned :) ) Let\u2019s say we want to increase the number of pods to 10. Try out kubectl scale deploy --replicas=10 nginx-deployment . You can see that 3/10 pods are older than the rest. This means Kubernetes has added 7 extra pods to scale the deployment to 10. This shows how simple it is to scale up and scale down containers using Kubernetes. Let\u2019s put all these pods behind a ClusterIP service. Execute kubectl expose deployment nginx-deployment --name=nginx-service . Curl the IP corresponding to 10.96.114.184. This curl request reaches one of the 10 pods in the deployment \u201cnginx-deployment\u201d in a round robin fashion. What happens when we execute the expose command is that a kubernetes Service is created of type Cluster IP so that all the pods behind this service are accessible through a single local IP (10.96.114.184, here). It is possible to have a public IP instead (i.e an actual external load balancer) by creating a Service of type LoadBalancer . Do feel free to play around with it! The above exercises a pretty good exposure to using Kubernetes to manage large scale deployments. Trust me, the process is very similar to the above for operating 1000 deployments and containers too! While a Deployment object is good enough for managing stateless applications, Kuberenetes provides other resources like Job, Daemonset, Cronjob, Statefulset etc. to manage special use cases. eAdditional labs: https://www.katacoda.com/lizrice/scenarios/kube-web https://www.katacoda.com/courses/kubernetes (Huge number of free follow-along exercises to play with Kubernetes) Advanced topics Most often than not, microservices orchestrated with Kubernetes contain dozens of instances of resources like deployment, services and configs. The manifests for these applications can be auto- generated with Helm templates and passed on as Helm charts. Similar to how we have PiPy for python packages there are remote repositories like Bitnami where Helm charts (e.g for setting up a production-ready Prometheus or Kafka with a single click) can be downloaded and used. This is a good place to begin . Kuberenetes provides the flexibility to create our custom resources (similar to Deployment or the Pod which we saw). For instance, if you want to create 5 instances of a resource with kind as SchoolOfSre you can! The only thing is that you have to write your custom resource for it. You can also build a custom operator for your custom resource to take certain actions on the resource instance. You can check here for more information.","title":"Orchestration With Kubernetes"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#introduction","text":"Now we finally arrive at the most awaited part: running and managing containers at scale. So far, we have seen how Docker facilitates managing the life-cycle of containers and provides improved portability of applications. Docker does provide a solution for easing the deployment of containers on a large scale ( you can check out Docker Swarm, if interested) which integrates well with Docker containers. However, Kubernetes has become the de-facto tool for orchestrating the management of microservices (as containers) in large distributed environments. Let\u2019s see the points of interest for us, SREs, to use container orchestration tools and Kubernetes in particular.","title":"Introduction"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#motivation-to-use-kubernetes","text":"Ease of usage Though there is a steep learning curve associated with Kubernetes, once learnt , can be used as a one stop tool to manage your microservices. With a single command it is possible to deploy full fledged production ready environments. The desired state of an application needs to be recorded as a YAML manifest and Kubernetes manages the application for you. Ensure optimum usage of resources We can specify limits on resources used by each container in a deployment. We can also specify our choice of nodes where Kubernetes can schedule nodes to be deployed (e.g microservices with high CPU consumption can be instructed to be deployed in high compute nodes). Fault tolerance Self-healing is built into basic resource types of Kubernetes. This removes the headache of designing a fault tolerant application system from scratch. This applies especially to stateless applications. Infrastructure agnostic Kubernetes does not have vendor lock-in. It can be set up in multiple cloud environments or in on-prem data centers. Strong community support and documentation Kubernetes is open-source and many technologies like operators, service mesh etc. have been built by the community to manage and monitor Kubernetes-orchestrated applications better. Extensible and customisable We can build our custom resource definitions which fit our use case for managing applications and use Kubernetes to manage them (with custom controllers). You can check out this article if you are more interested in this topic.","title":"Motivation to use Kubernetes"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#architecture-of-kubernetes","text":"Here\u2019s a diagram (from the official Kubernetes documentation ) containing different components which make Kubernetes work: Kubernetes components can be divided into two parts: control plane components and data plane components . A Kubernetes cluster consists of 1 or more host machines (called nodes) where the containers managed by Kubernetes are run. This constitutes the data plane (or node plane). The brain of Kuberentes which responds to events from the node plane (e.g create a pod, replicas mismatch) and does the main orchestration is called the control plane. All control plane components are typically installed in a master node. This master node does not run any user containers. The Kubernetes components themselves are run as containers wrapped in Pods (which is the most basic kubernetes resource object). Control plane components: kube-apiserver etcd kube-scheduler kube-controller-manager Node plane components kubelet kube-proxy This workflow might help you understand the working on components better: An SRE installs kubectl in their local machine. This is the client which interacts with the Kubernetes control plane (and hence the cluster). They create a YAML file, called manifest which specifies the desired state of the resource (e.g a deployment names \u201cfrontend\u201d needs 3 pods to always be running) When they issue a command to create objects based in the YAML file, the kubectl CLI tool sends a rest API request to the kube-apiserver . If the manifest is valid, it is stored as key value pairs in the etcd server on the control plane. kube-scheduler chooses which nodes to put the containers on (basically schedules them) There are controller processes (managed by kube-controller manager) which makes sure the current state of the cluster is equivalent to the desired state (here, 3 pods are indeed running in the cluster -> all is fine). On the node plane side, kubelet makes sure that pods are locally kept in running state.","title":"Architecture of Kubernetes"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#lab","text":"","title":"LAB"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#prerequisites","text":"The best way to start this exercise is to use a Katacoda kubernetes playground . A single node kubernetes cluster is already set up for you here for quick experimentation. You can also use this to play with docker. The environment gets torn down after 10 mins. So make sure that you save your files if you want to resume them. For persistent kubernetes clusters, you can set it up either in your local (using minikube ) or you can create a kubernetes cluster in Azure , GCP or any other cloud provider. Knowledge of YAML is nice to have for understanding the manifest files.","title":"Prerequisites"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#hands-on","text":"","title":"Hands-on"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#lab-1","text":"We are going to create an object called Pod which is the most basic unit for running a container in Kubernetes. Here, we will create a pod called \u2018nginx-pod\u201d which contains an nginx container called \u201cweb\u201d. We will also expose port 80 in the container so that we can interact with the nginx container. Save the below manifest in a file called nginx-pod.yaml apiVersion: v1 #[1] kind: Pod #[2] metadata: #[3] name: nginx-pod #[4] labels: #[5] app: nginx spec: #[6] containers: #[7] - name: web #[8] image: nginx #[9] ports: #[10] - name: web #[11] containerPort: 80 #[12] protocol: TCP #[13] Let\u2019s very briefly understand what\u2019s here: #[2] - kind: The \u201ckind\u201d of object that\u2019s being created. Here it is a Pod #[1] - apiVersion: The apiVersion of the \u201cPod\u201d resource. There could be minor changes in the values or keys in the yaml file if the version varies. #[3] - metadata: The metadata section of the file where pod labels and name is given #[6] - spec: This is the main part where the things inside the pod are defined These are not random key value pairs! They have to be interpretable by the kubeapiserver. You can check which key value pairs are optional/mandatory using kubectl explain pod command. Do try it out! Apply the manifest using the command kubectl apply -f nginx-pod.yaml . This creates the \u201cnginx-pod\u201d pod in the kubernetes cluster. Verify that the pod is in running state using kubectl get pod . It shows that nginx-pod is in Running state. 1/1 indicates that out of 1 out of 1 container(s) inside the pod is healthy. To check if the container running in \u201cnginx-pod\u201d is indeed \u201cweb\u201d we do the kubectl describe pod/nginx-pod command. This gives a lengthy output with a detailed description of the pod and the events that happened since the pod was created. This command is very useful for debugging. The part we are concerned here is this: You can see \u201cweb\u201d under the Containers section with Image as nginx. This is what we are looking for. How do we access the welcome page of nginx \u201cweb\u201d container? In the describe command you can see the IP address of the pod. Each pod is assigned an IP address on creation. Here, this is 10.244.1.3 Issue a curl request from the host curl 10.244.1.3:80 . You will get the welcome page! Let\u2019s say we want to use a specific tag of nginx (say 1.20.1) in the same pod i.e we want to modify some property of the pod. You can try editing nginx-pod.yaml (image: nginx:1.20.1 in #[9])and reapplying (step 2.). It will create a new container in the same pod with the new image. A container is created within the pod but the pod is the same. You can verify by checking the pod start time in describe command. It would show a much older time. You can actually see the nginx container by doing docker ps on the node01 terminal (if you\u2019re using Katacoda). What if we want to change the image to 1.20.1 for 1000 nginx pods? Stepping a little back, what if we want to create 1000 nginx pods. Of course, we can write a script but Kubernetes already offers a resource type called \u201cdeployment\u201d to manage large scale deployments better.","title":"Lab 1:"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#lab-2","text":"We\u2019ll go a step further to see how we can create more than a single instance of the nginx pod at the same time. We will first create Save the below manifest in a file called nginx-deploy.yaml apiVersion: apps/v1 kind: Deployment #[1] metadata: name: nginx-deployment labels: app: nginx spec: replicas: 3 #[2] selector: matchLabels: app: nginx #[3] template: #[4] metadata: labels: app: nginx #[5] spec: containers: - name: web image: nginx ports: - name: web containerPort: 80 protocol: \"TCP\" You can see that it is similar to a pod definition till spec ( #[1] has Deployment as kind, api version is also different). Another thing interesting observation is the metadata and spec parts under #[4] is almost the same as the metadata and spec section under the Pod definition in Lab 1 (do go up and cross check this). What this implies is that we are deploying 3 nginx pods similar to Lab1. Also, the labels in matchLabels should be the same as labels under #[4] . Now apply the manifest using kubectl apply -f nginx-deploy.yaml Verify that 3 pods are indeed created. If you\u2019re curious, check the output of kubectl get deploy and kubectl describe deploy nginx-deployment . Delete one of the 3 pods using kubectl delete pod . After a few seconds again do kubectl get pod . You can see that a new pod is spawned to keep the total number of pods as 3 (see AGE 15s compared to others created 27 minutes ago)! This is a demonstration of how Kubernetes does fault tolerance. This is a property of Kubernetes deployment object (kill the pod from Lab1, it won\u2019t be respawned :) ) Let\u2019s say we want to increase the number of pods to 10. Try out kubectl scale deploy --replicas=10 nginx-deployment . You can see that 3/10 pods are older than the rest. This means Kubernetes has added 7 extra pods to scale the deployment to 10. This shows how simple it is to scale up and scale down containers using Kubernetes. Let\u2019s put all these pods behind a ClusterIP service. Execute kubectl expose deployment nginx-deployment --name=nginx-service . Curl the IP corresponding to 10.96.114.184. This curl request reaches one of the 10 pods in the deployment \u201cnginx-deployment\u201d in a round robin fashion. What happens when we execute the expose command is that a kubernetes Service is created of type Cluster IP so that all the pods behind this service are accessible through a single local IP (10.96.114.184, here). It is possible to have a public IP instead (i.e an actual external load balancer) by creating a Service of type LoadBalancer . Do feel free to play around with it! The above exercises a pretty good exposure to using Kubernetes to manage large scale deployments. Trust me, the process is very similar to the above for operating 1000 deployments and containers too! While a Deployment object is good enough for managing stateless applications, Kuberenetes provides other resources like Job, Daemonset, Cronjob, Statefulset etc. to manage special use cases. eAdditional labs: https://www.katacoda.com/lizrice/scenarios/kube-web https://www.katacoda.com/courses/kubernetes (Huge number of free follow-along exercises to play with Kubernetes)","title":"Lab 2:"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#advanced-topics","text":"Most often than not, microservices orchestrated with Kubernetes contain dozens of instances of resources like deployment, services and configs. The manifests for these applications can be auto- generated with Helm templates and passed on as Helm charts. Similar to how we have PiPy for python packages there are remote repositories like Bitnami where Helm charts (e.g for setting up a production-ready Prometheus or Kafka with a single click) can be downloaded and used. This is a good place to begin . Kuberenetes provides the flexibility to create our custom resources (similar to Deployment or the Pod which we saw). For instance, if you want to create 5 instances of a resource with kind as SchoolOfSre you can! The only thing is that you have to write your custom resource for it. You can also build a custom operator for your custom resource to take certain actions on the resource instance. You can check here for more information.","title":"Advanced topics"}]} \ No newline at end of file +{"config":{"lang":["en"],"min_search_length":3,"prebuild_index":false,"separator":"[\\s\\-]+"},"docs":[{"location":"","text":"School of SRE In early 2019, we started visiting campuses across India to recruit the best and brightest minds to ensure LinkedIn, and all the services that make up its complex technology stack are always available for everyone. This critical function at LinkedIn falls under the purview of the Site Engineering team and Site Reliability Engineers (SREs) who are Software Engineers specializing in reliability. SREs apply the principles of computer science and engineering to the design, development, and operation of computer systems: generally, large-scale, distributed ones. As we continued on this journey we started getting a lot of questions from these campuses on what exactly the site reliability engineering role entails? And, how could someone learn the skills and the disciplines involved to become a successful site reliability engineer? Fast forward a few months, and a few of these campus students had joined LinkedIn either as interns or as full-time engineers to become a part of the Site Engineering team; we also had a few lateral hires who joined our organization who were not from a traditional SRE background. That's when a few of us got together and started to think about how we can onboard new graduate engineers to the Site Engineering team. There is a vast amount of resources scattered throughout the web on what the roles and responsibilities of SREs are, how to monitor site health, production incidents, define SLO/SLI, etc. But there are very few resources out there guiding someone on the basic skill sets one has to acquire as a beginner. Because of the lack of these resources, we felt that individuals have a tough time getting into open positions in the industry. We created the School Of SRE as a starting point for anyone wanting to build their career as an SRE. In this course, we are focusing on building strong foundational skills. The course is structured in a way to provide more real life examples and how learning each of these topics can play an important role in day to day SRE life. Currently we are covering the following topics under the School Of SRE: Fundamentals Series Linux Basics Git Linux Networking Python and Web Data Relational databases(MySQL) NoSQL concepts Big Data Systems Design Metrics and Monitoring Security We believe continuous learning will help in acquiring deeper knowledge and competencies in order to expand your skill sets, every module has added references that could be a guide for further learning. Our hope is that by going through these modules we should be able to build the essential skills required for a Site Reliability Engineer. At LinkedIn, we are using this curriculum for onboarding our non-traditional hires and new college grads into the SRE role. We had multiple rounds of successful onboarding experiences with new employees and the course helped them be productive in a very short period of time. This motivated us to open source the content for helping other organizations in onboarding new engineers into the role and provide guidance for aspiring individuals to get into the role. We realize that the initial content we created is just a starting point and we hope that the community can help in the journey of refining and expanding the content. Check out the contributing guide to get started.","title":"Home"},{"location":"#school-of-sre","text":"In early 2019, we started visiting campuses across India to recruit the best and brightest minds to ensure LinkedIn, and all the services that make up its complex technology stack are always available for everyone. This critical function at LinkedIn falls under the purview of the Site Engineering team and Site Reliability Engineers (SREs) who are Software Engineers specializing in reliability. SREs apply the principles of computer science and engineering to the design, development, and operation of computer systems: generally, large-scale, distributed ones. As we continued on this journey we started getting a lot of questions from these campuses on what exactly the site reliability engineering role entails? And, how could someone learn the skills and the disciplines involved to become a successful site reliability engineer? Fast forward a few months, and a few of these campus students had joined LinkedIn either as interns or as full-time engineers to become a part of the Site Engineering team; we also had a few lateral hires who joined our organization who were not from a traditional SRE background. That's when a few of us got together and started to think about how we can onboard new graduate engineers to the Site Engineering team. There is a vast amount of resources scattered throughout the web on what the roles and responsibilities of SREs are, how to monitor site health, production incidents, define SLO/SLI, etc. But there are very few resources out there guiding someone on the basic skill sets one has to acquire as a beginner. Because of the lack of these resources, we felt that individuals have a tough time getting into open positions in the industry. We created the School Of SRE as a starting point for anyone wanting to build their career as an SRE. In this course, we are focusing on building strong foundational skills. The course is structured in a way to provide more real life examples and how learning each of these topics can play an important role in day to day SRE life. Currently we are covering the following topics under the School Of SRE: Fundamentals Series Linux Basics Git Linux Networking Python and Web Data Relational databases(MySQL) NoSQL concepts Big Data Systems Design Metrics and Monitoring Security We believe continuous learning will help in acquiring deeper knowledge and competencies in order to expand your skill sets, every module has added references that could be a guide for further learning. Our hope is that by going through these modules we should be able to build the essential skills required for a Site Reliability Engineer. At LinkedIn, we are using this curriculum for onboarding our non-traditional hires and new college grads into the SRE role. We had multiple rounds of successful onboarding experiences with new employees and the course helped them be productive in a very short period of time. This motivated us to open source the content for helping other organizations in onboarding new engineers into the role and provide guidance for aspiring individuals to get into the role. We realize that the initial content we created is just a starting point and we hope that the community can help in the journey of refining and expanding the content. Check out the contributing guide to get started.","title":"School of SRE"},{"location":"CODE_OF_CONDUCT/","text":"This code of conduct outlines expectations for participation in LinkedIn-managed open source communities, as well as steps for reporting unacceptable behavior. We are committed to providing a welcoming and inspiring community for all. People violating this code of conduct may be banned from the community. Our open source communities strive to: Be friendly and patient: Remember you might not be communicating in someone else's primary spoken or programming language, and others may not have your level of understanding. Be welcoming: Our communities welcome and support people of all backgrounds and identities. This includes, but is not limited to members of any race, ethnicity, culture, national origin, color, immigration status, social and economic class, educational level, sex, sexual orientation, gender identity and expression, age, size, family status, political belief, religion, and mental and physical ability. Be respectful: We are a world-wide community of professionals, and we conduct ourselves professionally. Disagreement is no excuse for poor behavior and poor manners. Disrespectful and unacceptable behavior includes, but is not limited to: Violent threats or language. Discriminatory or derogatory jokes and language. Posting sexually explicit or violent material. Posting, or threatening to post, people's personally identifying information (\"doxing\"). Insults, especially those using discriminatory terms or slurs. Behavior that could be perceived as sexual attention. Advocating for or encouraging any of the above behaviors. Understand disagreements: Disagreements, both social and technical, are useful learning opportunities. Seek to understand the other viewpoints and resolve differences constructively. This code is not exhaustive or complete. It serves to capture our common understanding of a productive, collaborative environment. We expect the code to be followed in spirit as much as in the letter. Scope This code of conduct applies to all repos and communities for LinkedIn-managed open source projects regardless of whether or not the repo explicitly calls out its use of this code. The code also applies in public spaces when an individual is representing a project or its community. Examples include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. Note: Some LinkedIn-managed communities have codes of conduct that pre-date this document and issue resolution process. While communities are not required to change their code, they are expected to use the resolution process outlined here. The review team will coordinate with the communities involved to address your concerns. Reporting Code of Conduct Issues We encourage all communities to resolve issues on their own whenever possible. This builds a broader and deeper understanding and ultimately a healthier interaction. In the event that an issue cannot be resolved locally, please feel free to report your concerns by contacting oss@linkedin.com . In your report please include: Your contact information. Names (real, usernames or pseudonyms) of any individuals involved. If there are additional witnesses, please include them as well. Your account of what occurred, and if you believe the incident is ongoing. If there is a publicly available record (e.g. a mailing list archive or a public chat log), please include a link or attachment. Any additional information that may be helpful. All reports will be reviewed by a multi-person team and will result in a response that is deemed necessary and appropriate to the circumstances. Where additional perspectives are needed, the team may seek insight from others with relevant expertise or experience. The confidentiality of the person reporting the incident will be kept at all times. Involved parties are never part of the review team. Anyone asked to stop unacceptable behavior is expected to comply immediately. If an individual engages in unacceptable behavior, the review team may take any action they deem appropriate, including a permanent ban from the community. This code of conduct is based on the Microsoft Open Source Code of Conduct which was based on the template established by the TODO Group and used by numerous other large communities (e.g., Facebook , Yahoo , Twitter , GitHub ) and the Scope section from the Contributor Covenant version 1.4 .","title":"Code of Conduct"},{"location":"CODE_OF_CONDUCT/#scope","text":"This code of conduct applies to all repos and communities for LinkedIn-managed open source projects regardless of whether or not the repo explicitly calls out its use of this code. The code also applies in public spaces when an individual is representing a project or its community. Examples include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. Note: Some LinkedIn-managed communities have codes of conduct that pre-date this document and issue resolution process. While communities are not required to change their code, they are expected to use the resolution process outlined here. The review team will coordinate with the communities involved to address your concerns.","title":"Scope"},{"location":"CODE_OF_CONDUCT/#reporting-code-of-conduct-issues","text":"We encourage all communities to resolve issues on their own whenever possible. This builds a broader and deeper understanding and ultimately a healthier interaction. In the event that an issue cannot be resolved locally, please feel free to report your concerns by contacting oss@linkedin.com . In your report please include: Your contact information. Names (real, usernames or pseudonyms) of any individuals involved. If there are additional witnesses, please include them as well. Your account of what occurred, and if you believe the incident is ongoing. If there is a publicly available record (e.g. a mailing list archive or a public chat log), please include a link or attachment. Any additional information that may be helpful. All reports will be reviewed by a multi-person team and will result in a response that is deemed necessary and appropriate to the circumstances. Where additional perspectives are needed, the team may seek insight from others with relevant expertise or experience. The confidentiality of the person reporting the incident will be kept at all times. Involved parties are never part of the review team. Anyone asked to stop unacceptable behavior is expected to comply immediately. If an individual engages in unacceptable behavior, the review team may take any action they deem appropriate, including a permanent ban from the community. This code of conduct is based on the Microsoft Open Source Code of Conduct which was based on the template established by the TODO Group and used by numerous other large communities (e.g., Facebook , Yahoo , Twitter , GitHub ) and the Scope section from the Contributor Covenant version 1.4 .","title":"Reporting Code of Conduct Issues"},{"location":"CONTRIBUTING/","text":"We realise that the initial content we created is just a starting point and our hope is that the community can help in the journey refining and extending the contents. As a contributor, you represent that the content you submit is not plagiarised. By submitting the content, you (and, if applicable, your employer) are licensing the submitted content to LinkedIn and the open source community subject to the Creative Commons Attribution 4.0 International Public License. Repository URL : https://github.com/linkedin/school-of-sre Contributing Guidelines Ensure that you adhere to the following guidelines: Should be about principles and concepts that can be applied in any company or individual project. Do not focus on particular tools or tech stack(which usually change over time). Adhere to the Code of Conduct . Should be relevant to the roles and responsibilities of an SRE. Should be locally tested (see steps for testing) and well formatted. It is good practice to open an issue first and discuss your changes before submitting a pull request. This way, you can incorporate ideas from others before you even start. Building and testing locally Run the following commands to build and view the site locally before opening a PR. python3 -m venv .venv source .venv/bin/activate pip install -r requirements.txt mkdocs build mkdocs serve Opening a PR Follow the GitHub PR workflow for your contributions. Fork this repo, create a feature branch, commit your changes and open a PR to this repo.","title":"Contribute"},{"location":"CONTRIBUTING/#contributing-guidelines","text":"Ensure that you adhere to the following guidelines: Should be about principles and concepts that can be applied in any company or individual project. Do not focus on particular tools or tech stack(which usually change over time). Adhere to the Code of Conduct . Should be relevant to the roles and responsibilities of an SRE. Should be locally tested (see steps for testing) and well formatted. It is good practice to open an issue first and discuss your changes before submitting a pull request. This way, you can incorporate ideas from others before you even start.","title":"Contributing Guidelines"},{"location":"CONTRIBUTING/#building-and-testing-locally","text":"Run the following commands to build and view the site locally before opening a PR. python3 -m venv .venv source .venv/bin/activate pip install -r requirements.txt mkdocs build mkdocs serve","title":"Building and testing locally"},{"location":"CONTRIBUTING/#opening-a-pr","text":"Follow the GitHub PR workflow for your contributions. Fork this repo, create a feature branch, commit your changes and open a PR to this repo.","title":"Opening a PR"},{"location":"sre_community/","text":"We are having an active LinkedIn community for School of SRE. Please join the group via : https://www.linkedin.com/groups/12493545/ The group has members with different levels of experience in site reliability engineering. There are active conversation on different technical topics centered around site reliability engineering. We encourage everyone to join the conversation and learn from each other and build a successful career in the SRE space.","title":"SRE Community"},{"location":"level101/big_data/evolution/","text":"Evolution of Hadoop Architecture of Hadoop HDFS The Hadoop Distributed File System (HDFS) is a distributed file system designed to run on commodity hardware. It has many similarities with existing distributed file systems. However, the differences from other distributed file systems are significant. HDFS is highly fault-tolerant and is designed to be deployed on low-cost hardware. HDFS provides high throughput access to application data and is suitable for applications that have large data sets. HDFS is part of the Apache Hadoop Core project . NameNode: is the arbitrator and central repository of file namespace in the cluster. The NameNode executes the operations such as opening, closing, and renaming files and directories. DataNode: manages the storage attached to the node on which it runs. It is responsible for serving all the read and writes requests. It performs operations on instructions on NameNode such as creation, deletion, and replications of blocks. Client: Responsible for getting the required metadata from the namenode and then communicating with the datanodes for reads and writes. YARN YARN stands for \u201cYet Another Resource Negotiator\u201c. It was introduced in Hadoop 2.0 to remove the bottleneck on Job Tracker which was present in Hadoop 1.0. YARN was described as a \u201cRedesigned Resource Manager\u201d at the time of its launching, but it has now evolved to be known as a large-scale distributed operating system used for Big Data processing. The main components of YARN architecture include: Client: It submits map-reduce(MR) jobs to the resource manager. Resource Manager: It is the master daemon of YARN and is responsible for resource assignment and management among all the applications. Whenever it receives a processing request, it forwards it to the corresponding node manager and allocates resources for the completion of the request accordingly. It has two major components: Scheduler: It performs scheduling based on the allocated application and available resources. It is a pure scheduler, which means that it does not perform other tasks such as monitoring or tracking and does not guarantee a restart if a task fails. The YARN scheduler supports plugins such as Capacity Scheduler and Fair Scheduler to partition the cluster resources. Application manager: It is responsible for accepting the application and negotiating the first container from the resource manager. It also restarts the Application Manager container if a task fails. Node Manager: It takes care of individual nodes on the Hadoop cluster and manages application and workflow and that particular node. Its primary job is to keep up with the Node Manager. It monitors resource usage, performs log management, and also kills a container based on directions from the resource manager. It is also responsible for creating the container process and starting it at the request of the Application master. Application Master: An application is a single job submitted to a framework. The application manager is responsible for negotiating resources with the resource manager, tracking the status, and monitoring the progress of a single application. The application master requests the container from the node manager by sending a Container Launch Context(CLC) which includes everything an application needs to run. Once the application is started, it sends the health report to the resource manager from time-to-time. Container: It is a collection of physical resources such as RAM, CPU cores, and disk on a single node. The containers are invoked by Container Launch Context(CLC) which is a record that contains information such as environment variables, security tokens, dependencies, etc. MapReduce framework The term MapReduce represents two separate and distinct tasks Hadoop programs perform-Map Job and Reduce Job. Map jobs take data sets as input and process them to produce key-value pairs. Reduce job takes the output of the Map job i.e. the key-value pairs and aggregates them to produce desired results. Hadoop MapReduce (Hadoop Map/Reduce) is a software framework for distributed processing of large data sets on computing clusters. Mapreduce helps to split the input data set into a number of parts and run a program on all data parts parallel at once. Please find the below Word count example demonstrating the usage of the MapReduce framework: Other tooling around Hadoop Hive Uses a language called HQL which is very SQL like. Gives non-programmers the ability to query and analyze data in Hadoop. Is basically an abstraction layer on top of map-reduce. Ex. HQL query: SELECT pet.name, comment FROM pet JOIN event ON (pet.name = event.name); In mysql: SELECT pet.name, comment FROM pet, event WHERE pet.name = event.name; Pig Uses a scripting language called Pig Latin, which is more workflow driven. Don't need to be an expert Java programmer but need a few coding skills. Is also an abstraction layer on top of map-reduce. Here is a quick question for you: What is the output of running the pig queries in the right column against the data present in the left column in the below image? Output: 7,Komal,Nayak,24,9848022334,trivendram 8,Bharathi,Nambiayar,24,9848022333,Chennai 5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 6,Archana,Mishra,23,9848022335,Chennai Spark Spark provides primitives for in-memory cluster computing that allows user programs to load data into a cluster\u2019s memory and query it repeatedly, making it well suited to machine learning algorithms. Presto Presto is a high performance, distributed SQL query engine for Big Data. Its architecture allows users to query a variety of data sources such as Hadoop, AWS S3, Alluxio, MySQL, Cassandra, Kafka, and MongoDB. Example presto query: use studentDB; show tables; SELECT roll_no, name FROM studentDB.studentDetails where section=\u2019A\u2019 limit 5; Data Serialisation and storage In order to transport the data over the network or to store on some persistent storage, we use the process of translating data structures or objects state into binary or textual form. We call this process serialization.. Avro data is stored in a container file (a .avro file) and its schema (the .avsc file) is stored with the data file. Apache Hive provides support to store a table as Avro and can also query data in this serialisation format.","title":"Evolution and Architecture of Hadoop"},{"location":"level101/big_data/evolution/#evolution-of-hadoop","text":"","title":"Evolution of Hadoop"},{"location":"level101/big_data/evolution/#architecture-of-hadoop","text":"HDFS The Hadoop Distributed File System (HDFS) is a distributed file system designed to run on commodity hardware. It has many similarities with existing distributed file systems. However, the differences from other distributed file systems are significant. HDFS is highly fault-tolerant and is designed to be deployed on low-cost hardware. HDFS provides high throughput access to application data and is suitable for applications that have large data sets. HDFS is part of the Apache Hadoop Core project . NameNode: is the arbitrator and central repository of file namespace in the cluster. The NameNode executes the operations such as opening, closing, and renaming files and directories. DataNode: manages the storage attached to the node on which it runs. It is responsible for serving all the read and writes requests. It performs operations on instructions on NameNode such as creation, deletion, and replications of blocks. Client: Responsible for getting the required metadata from the namenode and then communicating with the datanodes for reads and writes. YARN YARN stands for \u201cYet Another Resource Negotiator\u201c. It was introduced in Hadoop 2.0 to remove the bottleneck on Job Tracker which was present in Hadoop 1.0. YARN was described as a \u201cRedesigned Resource Manager\u201d at the time of its launching, but it has now evolved to be known as a large-scale distributed operating system used for Big Data processing. The main components of YARN architecture include: Client: It submits map-reduce(MR) jobs to the resource manager. Resource Manager: It is the master daemon of YARN and is responsible for resource assignment and management among all the applications. Whenever it receives a processing request, it forwards it to the corresponding node manager and allocates resources for the completion of the request accordingly. It has two major components: Scheduler: It performs scheduling based on the allocated application and available resources. It is a pure scheduler, which means that it does not perform other tasks such as monitoring or tracking and does not guarantee a restart if a task fails. The YARN scheduler supports plugins such as Capacity Scheduler and Fair Scheduler to partition the cluster resources. Application manager: It is responsible for accepting the application and negotiating the first container from the resource manager. It also restarts the Application Manager container if a task fails. Node Manager: It takes care of individual nodes on the Hadoop cluster and manages application and workflow and that particular node. Its primary job is to keep up with the Node Manager. It monitors resource usage, performs log management, and also kills a container based on directions from the resource manager. It is also responsible for creating the container process and starting it at the request of the Application master. Application Master: An application is a single job submitted to a framework. The application manager is responsible for negotiating resources with the resource manager, tracking the status, and monitoring the progress of a single application. The application master requests the container from the node manager by sending a Container Launch Context(CLC) which includes everything an application needs to run. Once the application is started, it sends the health report to the resource manager from time-to-time. Container: It is a collection of physical resources such as RAM, CPU cores, and disk on a single node. The containers are invoked by Container Launch Context(CLC) which is a record that contains information such as environment variables, security tokens, dependencies, etc.","title":"Architecture of Hadoop"},{"location":"level101/big_data/evolution/#mapreduce-framework","text":"The term MapReduce represents two separate and distinct tasks Hadoop programs perform-Map Job and Reduce Job. Map jobs take data sets as input and process them to produce key-value pairs. Reduce job takes the output of the Map job i.e. the key-value pairs and aggregates them to produce desired results. Hadoop MapReduce (Hadoop Map/Reduce) is a software framework for distributed processing of large data sets on computing clusters. Mapreduce helps to split the input data set into a number of parts and run a program on all data parts parallel at once. Please find the below Word count example demonstrating the usage of the MapReduce framework:","title":"MapReduce framework"},{"location":"level101/big_data/evolution/#other-tooling-around-hadoop","text":"Hive Uses a language called HQL which is very SQL like. Gives non-programmers the ability to query and analyze data in Hadoop. Is basically an abstraction layer on top of map-reduce. Ex. HQL query: SELECT pet.name, comment FROM pet JOIN event ON (pet.name = event.name); In mysql: SELECT pet.name, comment FROM pet, event WHERE pet.name = event.name; Pig Uses a scripting language called Pig Latin, which is more workflow driven. Don't need to be an expert Java programmer but need a few coding skills. Is also an abstraction layer on top of map-reduce. Here is a quick question for you: What is the output of running the pig queries in the right column against the data present in the left column in the below image? Output: 7,Komal,Nayak,24,9848022334,trivendram 8,Bharathi,Nambiayar,24,9848022333,Chennai 5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar 6,Archana,Mishra,23,9848022335,Chennai Spark Spark provides primitives for in-memory cluster computing that allows user programs to load data into a cluster\u2019s memory and query it repeatedly, making it well suited to machine learning algorithms. Presto Presto is a high performance, distributed SQL query engine for Big Data. Its architecture allows users to query a variety of data sources such as Hadoop, AWS S3, Alluxio, MySQL, Cassandra, Kafka, and MongoDB. Example presto query: use studentDB; show tables; SELECT roll_no, name FROM studentDB.studentDetails where section=\u2019A\u2019 limit 5;","title":"Other tooling around Hadoop"},{"location":"level101/big_data/evolution/#data-serialisation-and-storage","text":"In order to transport the data over the network or to store on some persistent storage, we use the process of translating data structures or objects state into binary or textual form. We call this process serialization.. Avro data is stored in a container file (a .avro file) and its schema (the .avsc file) is stored with the data file. Apache Hive provides support to store a table as Avro and can also query data in this serialisation format.","title":"Data Serialisation and storage"},{"location":"level101/big_data/intro/","text":"Big Data Prerequisites Basics of Linux File systems. Basic understanding of System Design. What to expect from this course This course covers the basics of Big Data and how it has evolved to become what it is today. We will take a look at a few realistic scenarios where Big Data would be a perfect fit. An interesting assignment on designing a Big Data system is followed by understanding the architecture of Hadoop and the tooling around it. What is not covered under this course Writing programs to draw analytics from data. Course Contents Overview of Big Data Usage of Big Data techniques Evolution of Hadoop Architecture of hadoop HDFS Yarn MapReduce framework Other tooling around hadoop Hive Pig Spark Presto Data Serialisation and storage Overview of Big Data Big Data is a collection of large datasets that cannot be processed using traditional computing techniques. It is not a single technique or a tool, rather it has become a complete subject, which involves various tools, techniques, and frameworks. Big Data could consist of Structured data Unstructured data Semi-structured data Characteristics of Big Data: Volume Variety Velocity Variability Examples of Big Data generation include stock exchanges, social media sites, jet engines, etc. Usage of Big Data Techniques Take the example of the traffic lights problem. There are more than 300,000 traffic lights in the US as of 2018. Let us assume that we placed a device on each of them to collect metrics and send it to a central metrics collection system. If each of the IoT devices sends 10 events per minute, we have 300000x10x60x24 = 432x10^7 events per day. How would you go about processing that and telling me how many of the signals were \u201cgreen\u201d at 10:45 am on a particular day? Consider the next example on Unified Payments Interface (UPI) transactions: We had about 1.15 billion UPI transactions in the month of October 2019 in India. If we try to extrapolate this data to about a year and try to find out some common payments that were happening through a particular UPI ID, how do you suggest we go about that?","title":"Introduction"},{"location":"level101/big_data/intro/#big-data","text":"","title":"Big Data"},{"location":"level101/big_data/intro/#prerequisites","text":"Basics of Linux File systems. Basic understanding of System Design.","title":"Prerequisites"},{"location":"level101/big_data/intro/#what-to-expect-from-this-course","text":"This course covers the basics of Big Data and how it has evolved to become what it is today. We will take a look at a few realistic scenarios where Big Data would be a perfect fit. An interesting assignment on designing a Big Data system is followed by understanding the architecture of Hadoop and the tooling around it.","title":"What to expect from this course"},{"location":"level101/big_data/intro/#what-is-not-covered-under-this-course","text":"Writing programs to draw analytics from data.","title":"What is not covered under this course"},{"location":"level101/big_data/intro/#course-contents","text":"Overview of Big Data Usage of Big Data techniques Evolution of Hadoop Architecture of hadoop HDFS Yarn MapReduce framework Other tooling around hadoop Hive Pig Spark Presto Data Serialisation and storage","title":"Course Contents"},{"location":"level101/big_data/intro/#overview-of-big-data","text":"Big Data is a collection of large datasets that cannot be processed using traditional computing techniques. It is not a single technique or a tool, rather it has become a complete subject, which involves various tools, techniques, and frameworks. Big Data could consist of Structured data Unstructured data Semi-structured data Characteristics of Big Data: Volume Variety Velocity Variability Examples of Big Data generation include stock exchanges, social media sites, jet engines, etc.","title":"Overview of Big Data"},{"location":"level101/big_data/intro/#usage-of-big-data-techniques","text":"Take the example of the traffic lights problem. There are more than 300,000 traffic lights in the US as of 2018. Let us assume that we placed a device on each of them to collect metrics and send it to a central metrics collection system. If each of the IoT devices sends 10 events per minute, we have 300000x10x60x24 = 432x10^7 events per day. How would you go about processing that and telling me how many of the signals were \u201cgreen\u201d at 10:45 am on a particular day? Consider the next example on Unified Payments Interface (UPI) transactions: We had about 1.15 billion UPI transactions in the month of October 2019 in India. If we try to extrapolate this data to about a year and try to find out some common payments that were happening through a particular UPI ID, how do you suggest we go about that?","title":"Usage of Big Data Techniques"},{"location":"level101/big_data/tasks/","text":"Tasks and conclusion Post-training tasks: Try setting up your own 3 node Hadoop cluster. A VM based solution can be found here Write a simple spark/MR job of your choice and understand how to generate analytics from data. Sample dataset can be found here References: Hadoop documentation HDFS Architecture YARN Architecture Google GFS paper","title":"Conclusion"},{"location":"level101/big_data/tasks/#tasks-and-conclusion","text":"","title":"Tasks and conclusion"},{"location":"level101/big_data/tasks/#post-training-tasks","text":"Try setting up your own 3 node Hadoop cluster. A VM based solution can be found here Write a simple spark/MR job of your choice and understand how to generate analytics from data. Sample dataset can be found here","title":"Post-training tasks:"},{"location":"level101/big_data/tasks/#references","text":"Hadoop documentation HDFS Architecture YARN Architecture Google GFS paper","title":"References:"},{"location":"level101/databases_nosql/further_reading/","text":"Conclusion We have covered basic concepts of NoSQL databases. There is much more to learn and do. We hope this course gives you a good start and inspires you to explore further. Further reading NoSQL: https://hostingdata.co.uk/nosql-database/ https://www.mongodb.com/nosql-explained https://www.mongodb.com/nosql-explained/nosql-vs-sql Cap Theorem http://www.julianbrowne.com/article/brewers-cap-theorem Scalability http://www.slideshare.net/jboner/scalability-availability-stability-patterns Eventual Consistency https://www.allthingsdistributed.com/2008/12/eventually_consistent.html https://www.toptal.com/big-data/consistent-hashing https://web.stanford.edu/class/cs244/papers/chord_TON_2003.pdf","title":"Conclusion"},{"location":"level101/databases_nosql/further_reading/#conclusion","text":"We have covered basic concepts of NoSQL databases. There is much more to learn and do. We hope this course gives you a good start and inspires you to explore further.","title":"Conclusion"},{"location":"level101/databases_nosql/further_reading/#further-reading","text":"NoSQL: https://hostingdata.co.uk/nosql-database/ https://www.mongodb.com/nosql-explained https://www.mongodb.com/nosql-explained/nosql-vs-sql Cap Theorem http://www.julianbrowne.com/article/brewers-cap-theorem Scalability http://www.slideshare.net/jboner/scalability-availability-stability-patterns Eventual Consistency https://www.allthingsdistributed.com/2008/12/eventually_consistent.html https://www.toptal.com/big-data/consistent-hashing https://web.stanford.edu/class/cs244/papers/chord_TON_2003.pdf","title":"Further reading"},{"location":"level101/databases_nosql/intro/","text":"NoSQL Concepts Prerequisites Relational Databases What to expect from this course At the end of training, you will have an understanding of what a NoSQL database is, what kind of advantages or disadvantages it has over traditional RDBMS, learn about different types of NoSQL databases and understand some of the underlying concepts & trade offs w.r.t to NoSQL. What is not covered under this course We will not be deep diving into any specific NoSQL Database. Course Contents Introduction to NoSQL CAP Theorem Data versioning Partitioning Hashing Quorum Introduction When people use the term \u201cNoSQL database\u201d, they typically use it to refer to any non-relational database. Some say the term \u201cNoSQL\u201d stands for \u201cnon SQL\u201d while others say it stands for \u201cnot only SQL.\u201d Either way, most agree that NoSQL databases are databases that store data in a format other than relational tables. A common misconception is that NoSQL databases or non-relational databases don\u2019t store relationship data well. NoSQL databases can store relationship data\u2014they just store it differently than relational databases do. In fact, when compared with SQL databases, many find modeling relationship data in NoSQL databases to be easier , because related data doesn\u2019t have to be split between tables. Such databases have existed since the late 1960s, but the name \"NoSQL\" was only coined in the early 21st century. NASA used a NoSQL database to track inventory for the Apollo mission. NoSQL databases emerged in the late 2000s as the cost of storage dramatically decreased. Gone were the days of needing to create a complex, difficult-to-manage data model simply for the purposes of reducing data duplication. Developers (rather than storage) were becoming the primary cost of software development, so NoSQL databases optimized for developer productivity. With the rise of Agile development methodology, NoSQL databases were developed with a focus on scaling, fast performance and at the same time allowed for frequent application changes and made programming easier. Types of NoSQL databases: Over time due to the way these NoSQL databases were developed to suit requirements at different companies, we ended up with quite a few types of them. However, they can be broadly classified into 4 types. Some of the databases can overlap between different types. They are Document databases: They store data in documents similar to JSON (JavaScript Object Notation) objects. Each document contains pairs of fields and values. The values can typically be a variety of types including things like strings, numbers, booleans, arrays, or objects, and their structures typically align with objects developers are working with in code. The advantages include intuitive data model & flexible schemas. Because of their variety of field value types and powerful query languages, document databases are great for a wide variety of use cases and can be used as a general purpose database. They can horizontally scale-out to accomodate large data volumes. Ex: MongoDB, Couchbase Key-Value databases: These are a simpler type of databases where each item contains keys and values. A value can typically only be retrieved by referencing its key, so learning how to query for a specific key-value pair is typically simple. Key-value databases are great for use cases where you need to store large amounts of data but you don\u2019t need to perform complex queries to retrieve it. Common use cases include storing user preferences or caching. Ex: Redis , DynamoDB , Voldemort / Venice (Linkedin), Wide-Column stores: They store data in tables, rows, and dynamic columns. Wide-column stores provide a lot of flexibility over relational databases because each row is not required to have the same columns. Many consider wide-column stores to be two-dimensional key-value databases. Wide-column stores are great for when you need to store large amounts of data and you can predict what your query patterns will be. Wide-column stores are commonly used for storing Internet of Things data and user profile data. Cassandra and HBase are two of the most popular wide-column stores. Graph Databases: These databases store data in nodes and edges. Nodes typically store information about people, places, and things while edges store information about the relationships between the nodes. The underlying storage mechanism of graph databases can vary. Some depend on a relational engine and \u201cstore\u201d the graph data in a table (although a table is a logical element, therefore this approach imposes another level of abstraction between the graph database, the graph database management system and the physical devices where the data is actually stored). Others use a key-value store or document-oriented database for storage, making them inherently NoSQL structures. Graph databases excel in use cases where you need to traverse relationships to look for patterns such as social networks, fraud detection, and recommendation engines. Ex: Neo4j Comparison Performance Scalability Flexibility Complexity Functionality Key Value high high high none Variable Document stores high Variable (high) high low Variable (low) Column DB high high moderate low minimal Graph Variable Variable high high Graph theory Differences between SQL and NoSQL The table below summarizes the main differences between SQL and NoSQL databases. SQL Databases NoSQL Databases Data Storage Model Tables with fixed rows and columns Document: JSON documents, Key-value: key-value pairs, Wide-column: tables with rows and dynamic columns, Graph: nodes and edges Primary Purpose General purpose Document: general purpose, Key-value: large amounts of data with simple lookup queries, Wide-column: large amounts of data with predictable query patterns, Graph: analyzing and traversing relationships between connected data Schemas Rigid Flexible Scaling Vertical (scale-up with a larger server) Horizontal (scale-out across commodity servers) Multi-Record ACID Transactions Supported Most do not support multi-record ACID transactions. However, some\u2014like MongoDB\u2014do. Joins Typically required Typically not required Data to Object Mapping Requires ORM (object-relational mapping) Many do not require ORMs. Document DB documents map directly to data structures in most popular programming languages. Advantages Flexible Data Models Most NoSQL systems feature flexible schemas. A flexible schema means you can easily modify your database schema to add or remove fields to support for evolving application requirements. This facilitates with continuous application development of new features without database operation overhead. Horizontal Scaling Most NoSQL systems allow you to scale horizontally, which means you can add in cheaper & commodity hardware, whenever you want to scale a system. On the other hand SQL systems generally scale Vertically (a more powerful server). NoSQL systems can also host huge data sets when compared to traditional SQL systems. Fast Queries NoSQL can generally be a lot faster than traditional SQL systems due to data denormalization and horizontal scaling. Most NoSQL systems also tend to store similar data together facilitating faster query responses. Developer productivity NoSQL systems tend to map data based on the programming data structures. As a result developers need to perform fewer data transformations leading to increased productivity & fewer bugs.","title":"Introduction"},{"location":"level101/databases_nosql/intro/#nosql-concepts","text":"","title":"NoSQL Concepts"},{"location":"level101/databases_nosql/intro/#prerequisites","text":"Relational Databases","title":"Prerequisites"},{"location":"level101/databases_nosql/intro/#what-to-expect-from-this-course","text":"At the end of training, you will have an understanding of what a NoSQL database is, what kind of advantages or disadvantages it has over traditional RDBMS, learn about different types of NoSQL databases and understand some of the underlying concepts & trade offs w.r.t to NoSQL.","title":"What to expect from this course"},{"location":"level101/databases_nosql/intro/#what-is-not-covered-under-this-course","text":"We will not be deep diving into any specific NoSQL Database.","title":"What is not covered under this course"},{"location":"level101/databases_nosql/intro/#course-contents","text":"Introduction to NoSQL CAP Theorem Data versioning Partitioning Hashing Quorum","title":"Course Contents"},{"location":"level101/databases_nosql/intro/#introduction","text":"When people use the term \u201cNoSQL database\u201d, they typically use it to refer to any non-relational database. Some say the term \u201cNoSQL\u201d stands for \u201cnon SQL\u201d while others say it stands for \u201cnot only SQL.\u201d Either way, most agree that NoSQL databases are databases that store data in a format other than relational tables. A common misconception is that NoSQL databases or non-relational databases don\u2019t store relationship data well. NoSQL databases can store relationship data\u2014they just store it differently than relational databases do. In fact, when compared with SQL databases, many find modeling relationship data in NoSQL databases to be easier , because related data doesn\u2019t have to be split between tables. Such databases have existed since the late 1960s, but the name \"NoSQL\" was only coined in the early 21st century. NASA used a NoSQL database to track inventory for the Apollo mission. NoSQL databases emerged in the late 2000s as the cost of storage dramatically decreased. Gone were the days of needing to create a complex, difficult-to-manage data model simply for the purposes of reducing data duplication. Developers (rather than storage) were becoming the primary cost of software development, so NoSQL databases optimized for developer productivity. With the rise of Agile development methodology, NoSQL databases were developed with a focus on scaling, fast performance and at the same time allowed for frequent application changes and made programming easier.","title":"Introduction"},{"location":"level101/databases_nosql/intro/#types-of-nosql-databases","text":"Over time due to the way these NoSQL databases were developed to suit requirements at different companies, we ended up with quite a few types of them. However, they can be broadly classified into 4 types. Some of the databases can overlap between different types. They are Document databases: They store data in documents similar to JSON (JavaScript Object Notation) objects. Each document contains pairs of fields and values. The values can typically be a variety of types including things like strings, numbers, booleans, arrays, or objects, and their structures typically align with objects developers are working with in code. The advantages include intuitive data model & flexible schemas. Because of their variety of field value types and powerful query languages, document databases are great for a wide variety of use cases and can be used as a general purpose database. They can horizontally scale-out to accomodate large data volumes. Ex: MongoDB, Couchbase Key-Value databases: These are a simpler type of databases where each item contains keys and values. A value can typically only be retrieved by referencing its key, so learning how to query for a specific key-value pair is typically simple. Key-value databases are great for use cases where you need to store large amounts of data but you don\u2019t need to perform complex queries to retrieve it. Common use cases include storing user preferences or caching. Ex: Redis , DynamoDB , Voldemort / Venice (Linkedin), Wide-Column stores: They store data in tables, rows, and dynamic columns. Wide-column stores provide a lot of flexibility over relational databases because each row is not required to have the same columns. Many consider wide-column stores to be two-dimensional key-value databases. Wide-column stores are great for when you need to store large amounts of data and you can predict what your query patterns will be. Wide-column stores are commonly used for storing Internet of Things data and user profile data. Cassandra and HBase are two of the most popular wide-column stores. Graph Databases: These databases store data in nodes and edges. Nodes typically store information about people, places, and things while edges store information about the relationships between the nodes. The underlying storage mechanism of graph databases can vary. Some depend on a relational engine and \u201cstore\u201d the graph data in a table (although a table is a logical element, therefore this approach imposes another level of abstraction between the graph database, the graph database management system and the physical devices where the data is actually stored). Others use a key-value store or document-oriented database for storage, making them inherently NoSQL structures. Graph databases excel in use cases where you need to traverse relationships to look for patterns such as social networks, fraud detection, and recommendation engines. Ex: Neo4j","title":"Types of NoSQL databases:"},{"location":"level101/databases_nosql/intro/#comparison","text":"Performance Scalability Flexibility Complexity Functionality Key Value high high high none Variable Document stores high Variable (high) high low Variable (low) Column DB high high moderate low minimal Graph Variable Variable high high Graph theory","title":"Comparison"},{"location":"level101/databases_nosql/intro/#differences-between-sql-and-nosql","text":"The table below summarizes the main differences between SQL and NoSQL databases. SQL Databases NoSQL Databases Data Storage Model Tables with fixed rows and columns Document: JSON documents, Key-value: key-value pairs, Wide-column: tables with rows and dynamic columns, Graph: nodes and edges Primary Purpose General purpose Document: general purpose, Key-value: large amounts of data with simple lookup queries, Wide-column: large amounts of data with predictable query patterns, Graph: analyzing and traversing relationships between connected data Schemas Rigid Flexible Scaling Vertical (scale-up with a larger server) Horizontal (scale-out across commodity servers) Multi-Record ACID Transactions Supported Most do not support multi-record ACID transactions. However, some\u2014like MongoDB\u2014do. Joins Typically required Typically not required Data to Object Mapping Requires ORM (object-relational mapping) Many do not require ORMs. Document DB documents map directly to data structures in most popular programming languages.","title":"Differences between SQL and NoSQL"},{"location":"level101/databases_nosql/intro/#advantages","text":"Flexible Data Models Most NoSQL systems feature flexible schemas. A flexible schema means you can easily modify your database schema to add or remove fields to support for evolving application requirements. This facilitates with continuous application development of new features without database operation overhead. Horizontal Scaling Most NoSQL systems allow you to scale horizontally, which means you can add in cheaper & commodity hardware, whenever you want to scale a system. On the other hand SQL systems generally scale Vertically (a more powerful server). NoSQL systems can also host huge data sets when compared to traditional SQL systems. Fast Queries NoSQL can generally be a lot faster than traditional SQL systems due to data denormalization and horizontal scaling. Most NoSQL systems also tend to store similar data together facilitating faster query responses. Developer productivity NoSQL systems tend to map data based on the programming data structures. As a result developers need to perform fewer data transformations leading to increased productivity & fewer bugs.","title":"Advantages"},{"location":"level101/databases_nosql/key_concepts/","text":"Key Concepts Lets looks at some of the key concepts when we talk about NoSQL or distributed systems CAP Theorem In a keynote titled \u201c Towards Robust Distributed Systems \u201d at ACM\u2019s PODC symposium in 2000 Eric Brewer came up with the so-called CAP-theorem which is widely adopted today by large web companies as well as in the NoSQL community. The CAP acronym stands for C onsistency, A vailability & P artition Tolerance. Consistency It refers to how consistent a system is after an execution. A distributed system is called consistent when a write made by a source is available for all readers of that shared data. Different NoSQL systems support different levels of consistency. Availability It refers to how a system responds to loss of functionality of different systems due to hardware and software failures. A high availability implies that a system is still available to handle operations (reads and writes) when a certain part of the system is down due to a failure or upgrade. Partition Tolerance It is the ability of the system to continue operations in the event of a network partition. A network partition occurs when a failure causes two or more islands of networks where the systems can\u2019t talk to each other across the islands temporarily or permanently. Brewer alleges that one can at most choose two of these three characteristics in a shared-data system. The CAP-theorem states that a choice can only be made for two options out of consistency, availability and partition tolerance. A growing number of use cases in large scale applications tend to value reliability implying that availability & redundancy are more valuable than consistency. As a result these systems struggle to meet ACID properties. They attain this by loosening on the consistency requirement i.e Eventual Consistency. Eventual Consistency means that all readers will see writes, as time goes on: \u201cIn a steady state, the system will eventually return the last written value\u201d. Clients therefore may face an inconsistent state of data as updates are in progress. For instance, in a replicated database updates may go to one node which replicates the latest version to all other nodes that contain a replica of the modified dataset so that the replica nodes eventually will have the latest version. NoSQL systems support different levels of eventual consistency models. For example: Read Your Own Writes Consistency Clients will see their updates immediately after they are written. The reads can hit nodes other than the one where it was written. However they might not see updates by other clients immediately. Session Consistency Clients will see the updates to their data within a session scope. This generally indicates that reads & writes occur on the same server. Other clients using the same nodes will receive the same updates. Casual Consistency A system provides causal consistency if the following condition holds: write operations that are related by potential causality are seen by each process of the system in order. Different processes may observe concurrent writes in different orders Eventual consistency is useful if concurrent updates of the same partitions of data are unlikely and if clients do not immediately depend on reading updates issued by themselves or by other clients. Depending on what consistency model was chosen for the system (or parts of it), determines where the requests are routed, ex: replicas. CAP alternatives illustration Choice Traits Examples Consistency + Availability (Forfeit Partitions) 2-phase commits Cache invalidation protocols Single-site databases Cluster databases LDAP xFS file system Consistency + Partition tolerance (Forfeit Availability) Pessimistic locking Make minority partitions unavailable Distributed databases Distributed locking Majority protocols Availability + Partition tolerance (Forfeit Consistency) expirations/leases conflict resolution optimistic DNS Web caching Versioning of Data in distributed systems When data is distributed across nodes, it can be modified on different nodes at the same time (assuming strict consistency is enforced). Questions arise on conflict resolution for concurrent updates. Some of the popular conflict resolution mechanism are Timestamps This is the most obvious solution. You sort updates based on chronological order and choose the latest update. However this relies on clock synchronization across different parts of the infrastructure. This gets even more complicated when parts of systems are spread across different geographic locations. Optimistic Locking You associate a unique value like a clock or counter with every data update. When a client wants to update data, it has to specify which version of data needs to be updated. This would mean you need to keep track of history of the data versions. Vector Clocks A vector clock is defined as a tuple of clock values from each node. In a distributed environment, each node maintains a tuple of such clock values which represent the state of the nodes itself and its peers/replicas. A clock value may be real timestamps derived from local clock or version no. Vector clocks illustration Vector clocks have the following advantages over other conflict resolution mechanism No dependency on synchronized clocks No total ordering of revision nos required for casual reasoning No need to store and maintain multiple versions of the data on different nodes. Partitioning When the amount of data crosses the capacity of a single node, we need to think of splitting data, creating replicas for load balancing & disaster recovery. Depending on how dynamic the infrastructure is, we have a few approaches that we can take. Memory cached These are partitioned in-memory databases that are primarily used for transient data. These databases are generally used as a front for traditional RDBMS. Most frequently used data is replicated from a rdbms into a memory database to facilitate fast queries and to take the load off from backend DB\u2019s. A very common example is memcached or couchbase. Clustering Traditional cluster mechanisms abstract away the cluster topology from clients. A client need not know where the actual data is residing and which node it is talking to. Clustering is very commonly used in traditional RDBMS where it can help scaling the persistent layer to a certain extent. Separating reads from writes In this method, you will have multiple replicas hosting the same data. The incoming writes are typically sent to a single node (Leader) or multiple nodes (multi-Leader), while the rest of the replicas (Follower) handle reads requests. The leader replicates writes asynchronously to all followers. However the write lag can\u2019t be completely avoided. Sometimes a leader can crash before it replicates all the data to a follower. When this happens, a follower with the most consistent data can be turned into a leader. As you can realize now, it is hard to enforce full consistency in this model. You also need to consider the ratio of read vs write traffic. This model won\u2019t make sense when writes are higher than reads. The replication methods can also vary widely. Some systems do a complete transfer of state periodically, while others use a delta state transfer approach. You could also transfer the state by transferring the operations in order. The followers can then apply the same operations as the leader to catch up. Sharding Sharing refers to dividing data in such a way that data is distributed evenly (both in terms of storage & processing power) across a cluster of nodes. It can also imply data locality, which means similar & related data is stored together to facilitate faster access. A shard in turn can be further replicated to meet load balancing or disaster recovery requirements. A single shard replica might take in all writes (single leader) or multiple replicas can take writes (multi-leader). Reads can be distributed across multiple replicas. Since data is now distributed across multiple nodes, clients should be able to consistently figure out where data is hosted. We will look at some of the common techniques below. The downside of sharding is that joins between shards is not possible. So an upstream/downstream application has to aggregate the results from multiple shards. Sharding example Hashing A hash function is a function that maps one piece of data\u2014typically describing some kind of object, often of arbitrary size\u2014to another piece of data, typically an integer, known as hash code , or simply hash . In a partitioned database, it is important to consistently map a key to a server/replica. For ex: you can use a very simple hash as a modulo function. _p = k mod n_ Where p -> partition, k -> primary key n -> no of nodes The downside of this simple hash is that, whenever the cluster topology changes, the data distribution also changes. When you are dealing with memory caches, it will be easy to distribute partitions around. Whenever a node joins/leaves a topology, partitions can reorder themselves, a cache miss can be re-populated from backend DB. However when you look at persistent data, it is not possible as the new node doesn\u2019t have the data needed to serve it. This brings us to consistent hashing. Consistent Hashing Consistent hashing is a distributed hashing scheme that operates independently of the number of servers or objects in a distributed hash table by assigning them a position on an abstract circle, or hash ring . This allows servers and objects to scale without affecting the overall system. Say that our hash function h() generates a 32-bit integer. Then, to determine to which server we will send a key k, we find the server s whose hash h(s) is the smallest integer that is larger than h(k). To make the process simpler, we assume the table is circular, which means that if we cannot find a server with a hash larger than h(k), we wrap around and start looking from the beginning of the array. Consistent hashing illustration In consistent hashing when a server is removed or added then only the keys from that server are relocated. For example, if server S3 is removed then, all keys from server S3 will be moved to server S4 but keys stored on server S4 and S2 are not relocated. But there is one problem, when server S3 is removed then keys from S3 are not equally distributed among remaining servers S4 and S2. They are only assigned to server S4 which increases the load on server S4. To evenly distribute the load among servers when a server is added or removed, it creates a fixed number of replicas ( known as virtual nodes) of each server and distributes it along the circle. So instead of server labels S1, S2 and S3, we will have S10 S11\u2026S19, S20 S21\u2026S29 and S30 S31\u2026S39. The factor for a number of replicas is also known as weight , depending on the situation. All keys which are mapped to replicas Sij are stored on server Si. To find a key we do the same thing, find the position of the key on the circle and then move forward until you find a server replica. If the server replica is Sij then the key is stored in server Si. Suppose server S3 is removed, then all S3 replicas with labels S30 S31 \u2026 S39 must be removed. Now the objects keys adjacent to S3X labels will be automatically re-assigned to S1X, S2X and S4X. All keys originally assigned to S1, S2 & S4 will not be moved. Similar things happen if we add a server. Suppose we want to add a server S5 as a replacement of S3 then we need to add labels S50 S51 \u2026 S59. In the ideal case, one-fourth of keys from S1, S2 and S4 will be reassigned to S5. When applied to persistent storages, further issues arise: if a node has left the scene, data stored on this node becomes unavailable, unless it has been replicated to other nodes before; in the opposite case of a new node joining the others, adjacent nodes are no longer responsible for some pieces of data which they still store but not get asked for anymore as the corresponding objects are no longer hashed to them by requesting clients. In order to address this issue, a replication factor (r) can be introduced. Introducing replicas in a partitioning scheme\u2014besides reliability benefits\u2014also makes it possible to spread workload for read requests that can go to any physical node responsible for a requested piece of data. Scalability doesn\u2019t work if the clients have to decide between multiple versions of the dataset, because they need to read from a quorum of servers which in turn reduces the efficiency of load balancing. Quorum Quorum is the minimum number of nodes in a cluster that must be online and be able to communicate with each other. If any additional node failure occurs beyond this threshold, the cluster will stop running. To attain a quorum, you need a majority of the nodes. Commonly it is (N/2 + 1), where N is the total no of nodes in the system. For ex, In a 3 node cluster, you need 2 nodes for a majority, In a 5 node cluster, you need 3 nodes for a majority, In a 6 node cluster, you need 4 nodes for a majority. Quorum example Network problems can cause communication failures among cluster nodes. One set of nodes might be able to communicate together across a functioning part of a network but not be able to communicate with a different set of nodes in another part of the network. This is known as split brain in cluster or cluster partitioning. Now the partition which has quorum is allowed to continue running the application. The other partitions are removed from the cluster. Eg: In a 5 node cluster, consider what happens if nodes 1, 2, and 3 can communicate with each other but not with nodes 4 and 5. Nodes 1, 2, and 3 constitute a majority, and they continue running as a cluster. Nodes 4 and 5, being a minority, stop running as a cluster. If node 3 loses communication with other nodes, all nodes stop running as a cluster. However, all functioning nodes will continue to listen for communication, so that when the network begins working again, the cluster can form and begin to run. Below diagram demonstrates Quorum selection on a cluster partitioned into two sets. Cluster Quorum example","title":"Key Concepts"},{"location":"level101/databases_nosql/key_concepts/#key-concepts","text":"Lets looks at some of the key concepts when we talk about NoSQL or distributed systems","title":"Key Concepts"},{"location":"level101/databases_nosql/key_concepts/#cap-theorem","text":"In a keynote titled \u201c Towards Robust Distributed Systems \u201d at ACM\u2019s PODC symposium in 2000 Eric Brewer came up with the so-called CAP-theorem which is widely adopted today by large web companies as well as in the NoSQL community. The CAP acronym stands for C onsistency, A vailability & P artition Tolerance. Consistency It refers to how consistent a system is after an execution. A distributed system is called consistent when a write made by a source is available for all readers of that shared data. Different NoSQL systems support different levels of consistency. Availability It refers to how a system responds to loss of functionality of different systems due to hardware and software failures. A high availability implies that a system is still available to handle operations (reads and writes) when a certain part of the system is down due to a failure or upgrade. Partition Tolerance It is the ability of the system to continue operations in the event of a network partition. A network partition occurs when a failure causes two or more islands of networks where the systems can\u2019t talk to each other across the islands temporarily or permanently. Brewer alleges that one can at most choose two of these three characteristics in a shared-data system. The CAP-theorem states that a choice can only be made for two options out of consistency, availability and partition tolerance. A growing number of use cases in large scale applications tend to value reliability implying that availability & redundancy are more valuable than consistency. As a result these systems struggle to meet ACID properties. They attain this by loosening on the consistency requirement i.e Eventual Consistency. Eventual Consistency means that all readers will see writes, as time goes on: \u201cIn a steady state, the system will eventually return the last written value\u201d. Clients therefore may face an inconsistent state of data as updates are in progress. For instance, in a replicated database updates may go to one node which replicates the latest version to all other nodes that contain a replica of the modified dataset so that the replica nodes eventually will have the latest version. NoSQL systems support different levels of eventual consistency models. For example: Read Your Own Writes Consistency Clients will see their updates immediately after they are written. The reads can hit nodes other than the one where it was written. However they might not see updates by other clients immediately. Session Consistency Clients will see the updates to their data within a session scope. This generally indicates that reads & writes occur on the same server. Other clients using the same nodes will receive the same updates. Casual Consistency A system provides causal consistency if the following condition holds: write operations that are related by potential causality are seen by each process of the system in order. Different processes may observe concurrent writes in different orders Eventual consistency is useful if concurrent updates of the same partitions of data are unlikely and if clients do not immediately depend on reading updates issued by themselves or by other clients. Depending on what consistency model was chosen for the system (or parts of it), determines where the requests are routed, ex: replicas. CAP alternatives illustration Choice Traits Examples Consistency + Availability (Forfeit Partitions) 2-phase commits Cache invalidation protocols Single-site databases Cluster databases LDAP xFS file system Consistency + Partition tolerance (Forfeit Availability) Pessimistic locking Make minority partitions unavailable Distributed databases Distributed locking Majority protocols Availability + Partition tolerance (Forfeit Consistency) expirations/leases conflict resolution optimistic DNS Web caching","title":"CAP Theorem"},{"location":"level101/databases_nosql/key_concepts/#versioning-of-data-in-distributed-systems","text":"When data is distributed across nodes, it can be modified on different nodes at the same time (assuming strict consistency is enforced). Questions arise on conflict resolution for concurrent updates. Some of the popular conflict resolution mechanism are Timestamps This is the most obvious solution. You sort updates based on chronological order and choose the latest update. However this relies on clock synchronization across different parts of the infrastructure. This gets even more complicated when parts of systems are spread across different geographic locations. Optimistic Locking You associate a unique value like a clock or counter with every data update. When a client wants to update data, it has to specify which version of data needs to be updated. This would mean you need to keep track of history of the data versions. Vector Clocks A vector clock is defined as a tuple of clock values from each node. In a distributed environment, each node maintains a tuple of such clock values which represent the state of the nodes itself and its peers/replicas. A clock value may be real timestamps derived from local clock or version no. Vector clocks illustration Vector clocks have the following advantages over other conflict resolution mechanism No dependency on synchronized clocks No total ordering of revision nos required for casual reasoning No need to store and maintain multiple versions of the data on different nodes.","title":"Versioning of Data in distributed systems"},{"location":"level101/databases_nosql/key_concepts/#partitioning","text":"When the amount of data crosses the capacity of a single node, we need to think of splitting data, creating replicas for load balancing & disaster recovery. Depending on how dynamic the infrastructure is, we have a few approaches that we can take. Memory cached These are partitioned in-memory databases that are primarily used for transient data. These databases are generally used as a front for traditional RDBMS. Most frequently used data is replicated from a rdbms into a memory database to facilitate fast queries and to take the load off from backend DB\u2019s. A very common example is memcached or couchbase. Clustering Traditional cluster mechanisms abstract away the cluster topology from clients. A client need not know where the actual data is residing and which node it is talking to. Clustering is very commonly used in traditional RDBMS where it can help scaling the persistent layer to a certain extent. Separating reads from writes In this method, you will have multiple replicas hosting the same data. The incoming writes are typically sent to a single node (Leader) or multiple nodes (multi-Leader), while the rest of the replicas (Follower) handle reads requests. The leader replicates writes asynchronously to all followers. However the write lag can\u2019t be completely avoided. Sometimes a leader can crash before it replicates all the data to a follower. When this happens, a follower with the most consistent data can be turned into a leader. As you can realize now, it is hard to enforce full consistency in this model. You also need to consider the ratio of read vs write traffic. This model won\u2019t make sense when writes are higher than reads. The replication methods can also vary widely. Some systems do a complete transfer of state periodically, while others use a delta state transfer approach. You could also transfer the state by transferring the operations in order. The followers can then apply the same operations as the leader to catch up. Sharding Sharing refers to dividing data in such a way that data is distributed evenly (both in terms of storage & processing power) across a cluster of nodes. It can also imply data locality, which means similar & related data is stored together to facilitate faster access. A shard in turn can be further replicated to meet load balancing or disaster recovery requirements. A single shard replica might take in all writes (single leader) or multiple replicas can take writes (multi-leader). Reads can be distributed across multiple replicas. Since data is now distributed across multiple nodes, clients should be able to consistently figure out where data is hosted. We will look at some of the common techniques below. The downside of sharding is that joins between shards is not possible. So an upstream/downstream application has to aggregate the results from multiple shards. Sharding example","title":"Partitioning"},{"location":"level101/databases_nosql/key_concepts/#hashing","text":"A hash function is a function that maps one piece of data\u2014typically describing some kind of object, often of arbitrary size\u2014to another piece of data, typically an integer, known as hash code , or simply hash . In a partitioned database, it is important to consistently map a key to a server/replica. For ex: you can use a very simple hash as a modulo function. _p = k mod n_ Where p -> partition, k -> primary key n -> no of nodes The downside of this simple hash is that, whenever the cluster topology changes, the data distribution also changes. When you are dealing with memory caches, it will be easy to distribute partitions around. Whenever a node joins/leaves a topology, partitions can reorder themselves, a cache miss can be re-populated from backend DB. However when you look at persistent data, it is not possible as the new node doesn\u2019t have the data needed to serve it. This brings us to consistent hashing.","title":"Hashing"},{"location":"level101/databases_nosql/key_concepts/#consistent-hashing","text":"Consistent hashing is a distributed hashing scheme that operates independently of the number of servers or objects in a distributed hash table by assigning them a position on an abstract circle, or hash ring . This allows servers and objects to scale without affecting the overall system. Say that our hash function h() generates a 32-bit integer. Then, to determine to which server we will send a key k, we find the server s whose hash h(s) is the smallest integer that is larger than h(k). To make the process simpler, we assume the table is circular, which means that if we cannot find a server with a hash larger than h(k), we wrap around and start looking from the beginning of the array. Consistent hashing illustration In consistent hashing when a server is removed or added then only the keys from that server are relocated. For example, if server S3 is removed then, all keys from server S3 will be moved to server S4 but keys stored on server S4 and S2 are not relocated. But there is one problem, when server S3 is removed then keys from S3 are not equally distributed among remaining servers S4 and S2. They are only assigned to server S4 which increases the load on server S4. To evenly distribute the load among servers when a server is added or removed, it creates a fixed number of replicas ( known as virtual nodes) of each server and distributes it along the circle. So instead of server labels S1, S2 and S3, we will have S10 S11\u2026S19, S20 S21\u2026S29 and S30 S31\u2026S39. The factor for a number of replicas is also known as weight , depending on the situation. All keys which are mapped to replicas Sij are stored on server Si. To find a key we do the same thing, find the position of the key on the circle and then move forward until you find a server replica. If the server replica is Sij then the key is stored in server Si. Suppose server S3 is removed, then all S3 replicas with labels S30 S31 \u2026 S39 must be removed. Now the objects keys adjacent to S3X labels will be automatically re-assigned to S1X, S2X and S4X. All keys originally assigned to S1, S2 & S4 will not be moved. Similar things happen if we add a server. Suppose we want to add a server S5 as a replacement of S3 then we need to add labels S50 S51 \u2026 S59. In the ideal case, one-fourth of keys from S1, S2 and S4 will be reassigned to S5. When applied to persistent storages, further issues arise: if a node has left the scene, data stored on this node becomes unavailable, unless it has been replicated to other nodes before; in the opposite case of a new node joining the others, adjacent nodes are no longer responsible for some pieces of data which they still store but not get asked for anymore as the corresponding objects are no longer hashed to them by requesting clients. In order to address this issue, a replication factor (r) can be introduced. Introducing replicas in a partitioning scheme\u2014besides reliability benefits\u2014also makes it possible to spread workload for read requests that can go to any physical node responsible for a requested piece of data. Scalability doesn\u2019t work if the clients have to decide between multiple versions of the dataset, because they need to read from a quorum of servers which in turn reduces the efficiency of load balancing.","title":"Consistent Hashing"},{"location":"level101/databases_nosql/key_concepts/#quorum","text":"Quorum is the minimum number of nodes in a cluster that must be online and be able to communicate with each other. If any additional node failure occurs beyond this threshold, the cluster will stop running. To attain a quorum, you need a majority of the nodes. Commonly it is (N/2 + 1), where N is the total no of nodes in the system. For ex, In a 3 node cluster, you need 2 nodes for a majority, In a 5 node cluster, you need 3 nodes for a majority, In a 6 node cluster, you need 4 nodes for a majority. Quorum example Network problems can cause communication failures among cluster nodes. One set of nodes might be able to communicate together across a functioning part of a network but not be able to communicate with a different set of nodes in another part of the network. This is known as split brain in cluster or cluster partitioning. Now the partition which has quorum is allowed to continue running the application. The other partitions are removed from the cluster. Eg: In a 5 node cluster, consider what happens if nodes 1, 2, and 3 can communicate with each other but not with nodes 4 and 5. Nodes 1, 2, and 3 constitute a majority, and they continue running as a cluster. Nodes 4 and 5, being a minority, stop running as a cluster. If node 3 loses communication with other nodes, all nodes stop running as a cluster. However, all functioning nodes will continue to listen for communication, so that when the network begins working again, the cluster can form and begin to run. Below diagram demonstrates Quorum selection on a cluster partitioned into two sets. Cluster Quorum example","title":"Quorum"},{"location":"level101/databases_sql/backup_recovery/","text":"Backup and Recovery Backups are a very crucial part of any database setup. They are generally a copy of the data that can be used to reconstruct the data in case of any major or minor crisis with the database. In general terms backups can be of two types:- Physical Backup - the data directory as it is on the disk Logical Backup - the table structure and records in it Both the above kinds of backups are supported by MySQL with different tools. It is the job of the SRE to identify which should be used when. Mysqldump This utility is available with MySQL installation. It helps in getting the logical backup of the database. It outputs a set of SQL statements to reconstruct the data. It is not recommended to use mysqldump for large tables as it might take a lot of time and the file size will be huge. However, for small tables it is the best and the quickest option. mysqldump [options] > dump_output.sql There are certain options that can be used with mysqldump to get an appropriate dump of the database. To dump all the databases mysqldump -u -p --all-databases > all_dbs.sql To dump specific databases mysqldump -u -p --databases db1 db2 db3 > dbs.sql To dump a single database mysqldump -u -p --databases db1 > db1.sql OR mysqldump -u -p db1 > db1.sql The difference between the above two commands is that the latter one does not contain the CREATE DATABASE command in the backup output. To dump specific tables in a database mysqldump -u -p db1 table1 table2 > db1_tables.sql To dump only table structures and no data mysqldump -u -p --no-data db1 > db1_structure.sql To dump only table data and no CREATE statements mysqldump -u -p --no-create-info db1 > db1_data.sql To dump only specific records from a table mysqldump -u -p --no-create-info db1 table1 --where=\u201dsalary>80000\u201d > db1_table1_80000.sql Mysqldump can also provide output in CSV, other delimited text or XML format to support use-cases if any. The backup from mysqldump utility is offline i.e. when the backup finishes it will not have the changes to the database which were made when the backup was going on. For example, if the backup started at 3 PM and finished at 4 PM, it will not have the changes made to the database between 3 and 4 PM. Restoring from mysqldump can be done in the following two ways:- From shell mysql -u -p < all_dbs.sql OR From shell if the database is already created mysql -u -p db1 < db1.sql From within MySQL shell mysql> source all_dbs.sql Percona Xtrabackup This utility is installed separately from the MySQL server and is open source, provided by Percona. It helps in getting the full or partial physical backup of the database. It provides online backup of the database i.e. it will have the changes made to the database when the backup was going on as explained at the end of the previous section. Full Backup - the complete backup of the database. Partial Backup - Incremental Cumulative - After one full backup, the next backups will have changes post the full backup. For example, we took a full backup on Sunday, from Monday onwards every backup will have changes after Sunday; so, Tuesday\u2019s backup will have Monday\u2019s changes as well, Wednesday\u2019s backup will have changes of Monday and Tuesday as well and so on. Differential - After one full backup, the next backups will have changes post the previous incremental backup. For example, we took a full backup on Sunday, Monday will have changes done after Sunday, Tuesday will have changes done after Monday, and so on. Percona xtrabackup allows us to get both full and incremental backups as we desire. However, incremental backups take less space than a full backup (if taken per day) but the restore time of incremental backups is more than that of full backups. Creating a full backup xtrabackup --defaults-file= --user= --password= --backup --target-dir= Example xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/ Some other options --stream - can be used to stream the backup files to standard output in a specified format. xbstream is the only option for now. --tmp-dir - set this to a tmp directory to be used for temporary files while taking backups. --parallel - set this to the number of threads that can be used to parallely copy data files to target directory. --compress - by default - quicklz is used. Set this to have the backup in compressed format. Each file is a .qp compressed file and can be extracted by qpress file archiver. --decompress - decompresses all the files which were compressed with the .qp extension. It will not delete the .qp files after decompression. To do that, use --remove-original along with this. Please note that the decompress option should be run separately from the xtrabackup command that used the compress option. Preparing a backup Once the backup is done with the --backup option, we need to prepare it in order to restore it. This is done to make the datafiles consistent with point-in-time. There might have been some transactions going on while the backup was being executed and those have changed the data files. When we prepare a backup, all those transactions are applied to the data files. xtrabackup --prepare --target-dir= Example xtrabackup --prepare --target-dir=/mnt/data/backup/ It is not recommended to halt a process which is preparing the backup as that might cause data file corruption and backup cannot be used further. The backup will have to be taken again. Restoring a Full Backup To restore the backup which is created and prepared from above commands, just copy everything from the backup target-dir to the data-dir of MySQL server, change the ownership of all files to mysql user (the linux user used by MySQL server) and start mysql. Or the below command can be used as well, xtrabackup --defaults-file=/etc/my.cnf --copy-back --target-dir=/mnt/data/backups/ Note - the backup has to be prepared in order to restore it. Creating Incremental backups Percona Xtrabackup helps create incremental backups, i.e only the changes can be backed up since the last backup. Every InnoDB page contains a log sequence number or LSN that is also mentioned as one of the last lines of backup and prepare commands. xtrabackup: Transaction log of lsn to was copied. OR InnoDB: Shutdown completed; log sequence number completed OK! This indicates that the backup has been taken till the log sequence number mentioned. This is a key information in understanding incremental backups and working towards automating one. Incremental backups do not compare data files for changes, instead, they go through the InnoDB pages and compare their LSN to the last backup\u2019s LSN. So, without one full backup, the incremental backups are useless. The xtrabackup command creates a xtrabackup_checkpoint file which has the information about the LSN of the backup. Below are the key contents of the file:- backup_type = full-backuped | incremental from_lsn = 0 (full backup) | to_lsn of last backup to_lsn = last_lsn = There is a difference between to_lsn and last_lsn . When the last_lsn is more than to_lsn that means there are transactions that ran while we took the backup and are yet to be applied. That is what --prepare is used for. To take incremental backups, first, we require one full backup. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/full/ Let\u2019s assume the contents of the xtrabackup_checkpoint file to be as follows. backup_type = full-backuped from_lsn = 0 to_lsn = 1000 last_lsn = 1000 Now that we have one full backup, we can have an incremental backup that takes the changes. We will go with differential incremental backups. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/incr1/ --incremental-basedir=/mnt/data/backup/full/ There are delta files created in the incr1 directory like, ibdata1.delta , db1/tbl1.ibd.delta with the changes from the full directory. The xtrabackup_checkpoint file will thus have the following contents. backup_type = incremental from_lsn = 1000 to_lsn = 1500 last_lsn = 1500 Hence, the from_lsn here is equal to the to_lsn of the last backup or the basedir provided for the incremental backups. For the next incremental backup we can use this incremental backup as the basedir. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/incr2/ --incremental-basedir=/mnt/data/backup/incr1/ The xtrabackup_checkpoint file will thus have the following contents. backup_type = incremental from_lsn = 1500 to_lsn = 2000 last_lsn = 2200 Preparing Incremental backups Preparing incremental backups is not the same as preparing a full backup. When prepare runs, two operations are performed - committed transactions are applied on the data files and uncommitted transactions are rolled back . While preparing incremental backups, we have to skip rollback of uncommitted transactions as it is likely that they might get committed in the next incremental backup. If we rollback uncommitted transactions the further incremental backups cannot be applied. We use --apply-log-only option along with --prepare to avoid the rollback phase. From the last section, we had the following directories with complete backup /mnt/data/backup/full /mnt/data/backup/incr1 /mnt/data/backup/incr2 First, we prepare the full backup, but only with the --apply-log-only option. xtrabackup --prepare --apply-log-only --target-dir=/mnt/data/backup/full The output of the command will contain the following at the end. InnoDB: Shutdown complete; log sequence number 1000 Completed OK! Note the LSN mentioned at the end is the same as the to_lsn from the xtrabackup_checkpoint created for full backup. Next, we apply the changes from the first incremental backup to the full backup. xtrabackup --prepare --apply-log-only --target-dir=/mnt/data/backup/full --incremental-dir=/mnt/data/backup/incr1 This applies the delta files in the incremental directory to the full backup directory. It rolls the data files in the full backup directory forward to the time of incremental backup and applies the redo logs as usual. Lastly, we apply the last incremental backup same as the previous one with just a small change. xtrabackup --prepare --target-dir=/mnt/data/backup/full --incremental-dir=/mnt/data/backup/incr1 We do not have to use the --apply-log-only option with it. It applies the incr2 delta files to the full backup data files taking them forward, applies redo logs on them and finally rollbacks the uncommitted transactions to produce the final result. The data now present in the full backup directory can now be used to restore. Note - To create cumulative incremental backups, the incremental-basedir should always be the full backup directory for every incremental backup. While preparing, we can start with the full backup with the --apply-log-only option and use just the last incremental backup for the final --prepare as that has all the changes since the full backup. Restoring Incremental backups Once all the above steps are completed, restoring is the same as done for a full backup. Further Reading MySQL Point-In-Time-Recovery Another MySQL backup tool - mysqlpump Another MySQL backup tool - mydumper A comparison between mysqldump, mysqlpump and mydumper Backup Best Practices","title":"Backup and Recovery"},{"location":"level101/databases_sql/backup_recovery/#backup-and-recovery","text":"Backups are a very crucial part of any database setup. They are generally a copy of the data that can be used to reconstruct the data in case of any major or minor crisis with the database. In general terms backups can be of two types:- Physical Backup - the data directory as it is on the disk Logical Backup - the table structure and records in it Both the above kinds of backups are supported by MySQL with different tools. It is the job of the SRE to identify which should be used when.","title":"Backup and Recovery"},{"location":"level101/databases_sql/backup_recovery/#mysqldump","text":"This utility is available with MySQL installation. It helps in getting the logical backup of the database. It outputs a set of SQL statements to reconstruct the data. It is not recommended to use mysqldump for large tables as it might take a lot of time and the file size will be huge. However, for small tables it is the best and the quickest option. mysqldump [options] > dump_output.sql There are certain options that can be used with mysqldump to get an appropriate dump of the database. To dump all the databases mysqldump -u -p --all-databases > all_dbs.sql To dump specific databases mysqldump -u -p --databases db1 db2 db3 > dbs.sql To dump a single database mysqldump -u -p --databases db1 > db1.sql OR mysqldump -u -p db1 > db1.sql The difference between the above two commands is that the latter one does not contain the CREATE DATABASE command in the backup output. To dump specific tables in a database mysqldump -u -p db1 table1 table2 > db1_tables.sql To dump only table structures and no data mysqldump -u -p --no-data db1 > db1_structure.sql To dump only table data and no CREATE statements mysqldump -u -p --no-create-info db1 > db1_data.sql To dump only specific records from a table mysqldump -u -p --no-create-info db1 table1 --where=\u201dsalary>80000\u201d > db1_table1_80000.sql Mysqldump can also provide output in CSV, other delimited text or XML format to support use-cases if any. The backup from mysqldump utility is offline i.e. when the backup finishes it will not have the changes to the database which were made when the backup was going on. For example, if the backup started at 3 PM and finished at 4 PM, it will not have the changes made to the database between 3 and 4 PM. Restoring from mysqldump can be done in the following two ways:- From shell mysql -u -p < all_dbs.sql OR From shell if the database is already created mysql -u -p db1 < db1.sql From within MySQL shell mysql> source all_dbs.sql","title":"Mysqldump"},{"location":"level101/databases_sql/backup_recovery/#percona-xtrabackup","text":"This utility is installed separately from the MySQL server and is open source, provided by Percona. It helps in getting the full or partial physical backup of the database. It provides online backup of the database i.e. it will have the changes made to the database when the backup was going on as explained at the end of the previous section. Full Backup - the complete backup of the database. Partial Backup - Incremental Cumulative - After one full backup, the next backups will have changes post the full backup. For example, we took a full backup on Sunday, from Monday onwards every backup will have changes after Sunday; so, Tuesday\u2019s backup will have Monday\u2019s changes as well, Wednesday\u2019s backup will have changes of Monday and Tuesday as well and so on. Differential - After one full backup, the next backups will have changes post the previous incremental backup. For example, we took a full backup on Sunday, Monday will have changes done after Sunday, Tuesday will have changes done after Monday, and so on. Percona xtrabackup allows us to get both full and incremental backups as we desire. However, incremental backups take less space than a full backup (if taken per day) but the restore time of incremental backups is more than that of full backups. Creating a full backup xtrabackup --defaults-file= --user= --password= --backup --target-dir= Example xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/ Some other options --stream - can be used to stream the backup files to standard output in a specified format. xbstream is the only option for now. --tmp-dir - set this to a tmp directory to be used for temporary files while taking backups. --parallel - set this to the number of threads that can be used to parallely copy data files to target directory. --compress - by default - quicklz is used. Set this to have the backup in compressed format. Each file is a .qp compressed file and can be extracted by qpress file archiver. --decompress - decompresses all the files which were compressed with the .qp extension. It will not delete the .qp files after decompression. To do that, use --remove-original along with this. Please note that the decompress option should be run separately from the xtrabackup command that used the compress option. Preparing a backup Once the backup is done with the --backup option, we need to prepare it in order to restore it. This is done to make the datafiles consistent with point-in-time. There might have been some transactions going on while the backup was being executed and those have changed the data files. When we prepare a backup, all those transactions are applied to the data files. xtrabackup --prepare --target-dir= Example xtrabackup --prepare --target-dir=/mnt/data/backup/ It is not recommended to halt a process which is preparing the backup as that might cause data file corruption and backup cannot be used further. The backup will have to be taken again. Restoring a Full Backup To restore the backup which is created and prepared from above commands, just copy everything from the backup target-dir to the data-dir of MySQL server, change the ownership of all files to mysql user (the linux user used by MySQL server) and start mysql. Or the below command can be used as well, xtrabackup --defaults-file=/etc/my.cnf --copy-back --target-dir=/mnt/data/backups/ Note - the backup has to be prepared in order to restore it. Creating Incremental backups Percona Xtrabackup helps create incremental backups, i.e only the changes can be backed up since the last backup. Every InnoDB page contains a log sequence number or LSN that is also mentioned as one of the last lines of backup and prepare commands. xtrabackup: Transaction log of lsn to was copied. OR InnoDB: Shutdown completed; log sequence number completed OK! This indicates that the backup has been taken till the log sequence number mentioned. This is a key information in understanding incremental backups and working towards automating one. Incremental backups do not compare data files for changes, instead, they go through the InnoDB pages and compare their LSN to the last backup\u2019s LSN. So, without one full backup, the incremental backups are useless. The xtrabackup command creates a xtrabackup_checkpoint file which has the information about the LSN of the backup. Below are the key contents of the file:- backup_type = full-backuped | incremental from_lsn = 0 (full backup) | to_lsn of last backup to_lsn = last_lsn = There is a difference between to_lsn and last_lsn . When the last_lsn is more than to_lsn that means there are transactions that ran while we took the backup and are yet to be applied. That is what --prepare is used for. To take incremental backups, first, we require one full backup. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/full/ Let\u2019s assume the contents of the xtrabackup_checkpoint file to be as follows. backup_type = full-backuped from_lsn = 0 to_lsn = 1000 last_lsn = 1000 Now that we have one full backup, we can have an incremental backup that takes the changes. We will go with differential incremental backups. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/incr1/ --incremental-basedir=/mnt/data/backup/full/ There are delta files created in the incr1 directory like, ibdata1.delta , db1/tbl1.ibd.delta with the changes from the full directory. The xtrabackup_checkpoint file will thus have the following contents. backup_type = incremental from_lsn = 1000 to_lsn = 1500 last_lsn = 1500 Hence, the from_lsn here is equal to the to_lsn of the last backup or the basedir provided for the incremental backups. For the next incremental backup we can use this incremental backup as the basedir. xtrabackup --defaults-file=/etc/my.cnf --user=some_user --password=XXXX --backup --target-dir=/mnt/data/backup/incr2/ --incremental-basedir=/mnt/data/backup/incr1/ The xtrabackup_checkpoint file will thus have the following contents. backup_type = incremental from_lsn = 1500 to_lsn = 2000 last_lsn = 2200 Preparing Incremental backups Preparing incremental backups is not the same as preparing a full backup. When prepare runs, two operations are performed - committed transactions are applied on the data files and uncommitted transactions are rolled back . While preparing incremental backups, we have to skip rollback of uncommitted transactions as it is likely that they might get committed in the next incremental backup. If we rollback uncommitted transactions the further incremental backups cannot be applied. We use --apply-log-only option along with --prepare to avoid the rollback phase. From the last section, we had the following directories with complete backup /mnt/data/backup/full /mnt/data/backup/incr1 /mnt/data/backup/incr2 First, we prepare the full backup, but only with the --apply-log-only option. xtrabackup --prepare --apply-log-only --target-dir=/mnt/data/backup/full The output of the command will contain the following at the end. InnoDB: Shutdown complete; log sequence number 1000 Completed OK! Note the LSN mentioned at the end is the same as the to_lsn from the xtrabackup_checkpoint created for full backup. Next, we apply the changes from the first incremental backup to the full backup. xtrabackup --prepare --apply-log-only --target-dir=/mnt/data/backup/full --incremental-dir=/mnt/data/backup/incr1 This applies the delta files in the incremental directory to the full backup directory. It rolls the data files in the full backup directory forward to the time of incremental backup and applies the redo logs as usual. Lastly, we apply the last incremental backup same as the previous one with just a small change. xtrabackup --prepare --target-dir=/mnt/data/backup/full --incremental-dir=/mnt/data/backup/incr1 We do not have to use the --apply-log-only option with it. It applies the incr2 delta files to the full backup data files taking them forward, applies redo logs on them and finally rollbacks the uncommitted transactions to produce the final result. The data now present in the full backup directory can now be used to restore. Note - To create cumulative incremental backups, the incremental-basedir should always be the full backup directory for every incremental backup. While preparing, we can start with the full backup with the --apply-log-only option and use just the last incremental backup for the final --prepare as that has all the changes since the full backup. Restoring Incremental backups Once all the above steps are completed, restoring is the same as done for a full backup.","title":"Percona Xtrabackup"},{"location":"level101/databases_sql/backup_recovery/#further-reading","text":"MySQL Point-In-Time-Recovery Another MySQL backup tool - mysqlpump Another MySQL backup tool - mydumper A comparison between mysqldump, mysqlpump and mydumper Backup Best Practices","title":"Further Reading"},{"location":"level101/databases_sql/concepts/","text":"Relational DBs are used for data storage. Even a file can be used to store data, but relational DBs are designed with specific goals: Efficiency Ease of access and management Organized Handle relations between data (represented as tables) Transaction: a unit of work that can comprise multiple statements, executed together ACID properties Set of properties that guarantee data integrity of DB transactions Atomicity: Each transaction is atomic (succeeds or fails completely) Consistency: Transactions only result in valid state (which includes rules, constraints, triggers etc.) Isolation: Each transaction is executed independently of others safely within a concurrent system Durability: Completed transactions will not be lost due to any later failures Let\u2019s take some examples to illustrate the above properties. Account A has a balance of \u20b9200 & B has \u20b9400. Account A is transferring \u20b9100 to Account B. This transaction has a deduction from sender and an addition into the recipient\u2019s balance. If the first operation passes successfully while the second fails, A\u2019s balance would be \u20b9100 while B would be having \u20b9400 instead of \u20b9500. Atomicity in a DB ensures this partially failed transaction is rolled back. If the second operation above fails, it leaves the DB inconsistent (sum of balance of accounts before and after the operation is not the same). Consistency ensures that this does not happen. There are three operations, one to calculate interest for A\u2019s account, another to add that to A\u2019s account, then transfer \u20b9100 from B to A. Without isolation guarantees, concurrent execution of these 3 operations may lead to a different outcome every time. What happens if the system crashes before the transactions are written to disk? Durability ensures that the changes are applied correctly during recovery. Relational data Tables represent relations Columns (fields) represent attributes Rows are individual records Schema describes the structure of DB SQL A query language to interact with and manage data. CRUD operations - create, read, update, delete queries Management operations - create DBs/tables/indexes etc, backup, import/export, users, access controls Exercise: Classify the below queries into the four types - DDL (definition), DML(manipulation), DCL(control) and TCL(transactions) and explain in detail. insert, create, drop, delete, update, commit, rollback, truncate, alter, grant, revoke You can practise these in the lab section . Constraints Rules for data that can be stored. Query fails if you violate any of these defined on a table. Primary key: one or more columns that contain UNIQUE values, and cannot contain NULL values. A table can have only ONE primary key. An index on it is created by default. Foreign key: links two tables together. Its value(s) match a primary key in a different table \\ Not null: Does not allow null values \\ Unique: Value of column must be unique across all rows \\ Default: Provides a default value for a column if none is specified during insert Check: Allows only particular values (like Balance >= 0) Indexes Most indexes use B+ tree structure. Why use them: Speeds up queries (in large tables that fetch only a few rows, min/max queries, by eliminating rows from consideration etc) Types of indexes: unique, primary key, fulltext, secondary Write-heavy loads, mostly full table scans or accessing large number of rows etc. do not benefit from indexes Joins Allows you to fetch related data from multiple tables, linking them together with some common field. Powerful but also resource-intensive and makes scaling databases difficult. This is the cause of many slow performing queries when run at scale, and the solution is almost always to find ways to reduce the joins. Access control DBs have privileged accounts for admin tasks, and regular accounts for clients. There are finegrained controls on what actions(DDL, DML etc. discussed earlier )are allowed for these accounts. DB first verifies the user credentials (authentication), and then examines whether this user is permitted to perform the request (authorization) by looking up these information in some internal tables. Other controls include activity auditing that allows examining the history of actions done by a user, and resource limits which define the number of queries, connections etc. allowed. Popular databases Commercial, closed source - Oracle, Microsoft SQL Server, IBM DB2 Open source with optional paid support - MySQL, MariaDB, PostgreSQL Individuals and small companies have always preferred open source DBs because of the huge cost associated with commercial software. In recent times, even large organizations have moved away from commercial software to open source alternatives because of the flexibility and cost savings associated with it. Lack of support is no longer a concern because of the paid support available from the developer and third parties. MySQL is the most widely used open source DB, and it is widely supported by hosting providers, making it easy for anyone to use. It is part of the popular Linux-Apache-MySQL-PHP ( LAMP ) stack that became popular in the 2000s. We have many more choices for a programming language, but the rest of that stack is still widely used.","title":"Key Concepts"},{"location":"level101/databases_sql/concepts/#popular-databases","text":"Commercial, closed source - Oracle, Microsoft SQL Server, IBM DB2 Open source with optional paid support - MySQL, MariaDB, PostgreSQL Individuals and small companies have always preferred open source DBs because of the huge cost associated with commercial software. In recent times, even large organizations have moved away from commercial software to open source alternatives because of the flexibility and cost savings associated with it. Lack of support is no longer a concern because of the paid support available from the developer and third parties. MySQL is the most widely used open source DB, and it is widely supported by hosting providers, making it easy for anyone to use. It is part of the popular Linux-Apache-MySQL-PHP ( LAMP ) stack that became popular in the 2000s. We have many more choices for a programming language, but the rest of that stack is still widely used.","title":"Popular databases"},{"location":"level101/databases_sql/conclusion/","text":"Conclusion We have covered basic concepts of SQL databases. We have also covered some of the tasks that an SRE may be responsible for - there is so much more to learn and do. We hope this course gives you a good start and inspires you to explore further. Further reading More practice with online resources like this one Normalization Routines , triggers Views Transaction isolation levels Sharding Setting up HA , monitoring , backups","title":"Conclusion"},{"location":"level101/databases_sql/conclusion/#conclusion","text":"We have covered basic concepts of SQL databases. We have also covered some of the tasks that an SRE may be responsible for - there is so much more to learn and do. We hope this course gives you a good start and inspires you to explore further.","title":"Conclusion"},{"location":"level101/databases_sql/conclusion/#further-reading","text":"More practice with online resources like this one Normalization Routines , triggers Views Transaction isolation levels Sharding Setting up HA , monitoring , backups","title":"Further reading"},{"location":"level101/databases_sql/innodb/","text":"Why should you use this? General purpose, row level locking, ACID support, transactions, crash recovery and multi-version concurrency control etc. Architecture Key components: Memory: Buffer pool: LRU cache of frequently used data(table and index) to be processed directly from memory, which speeds up processing. Important for tuning performance. Change buffer: Caches changes to secondary index pages when those pages are not in the buffer pool and merges it when they are fetched. Merging may take a long time and impact live queries. It also takes up part of the buffer pool. Avoids the extra I/O to read secondary indexes in. Adaptive hash index: Supplements InnoDB\u2019s B-Tree indexes with fast hash lookup tables like a cache. Slight performance penalty for misses, also adds maintenance overhead of updating it. Hash collisions cause AHI rebuilding for large DBs. Log buffer: Holds log data before flush to disk. Size of each above memory is configurable, and impacts performance a lot. Requires careful analysis of workload, available resources, benchmarking and tuning for optimal performance. Disk: Tables: Stores data within rows and columns. Indexes: Helps find rows with specific column values quickly, avoids full table scans. Redo Logs: all transactions are written to them, and after a crash, the recovery process corrects data written by incomplete transactions and replays any pending ones. Undo Logs: Records associated with a single transaction that contains information about how to undo the latest change by a transaction.","title":"InnoDB"},{"location":"level101/databases_sql/innodb/#why-should-you-use-this","text":"General purpose, row level locking, ACID support, transactions, crash recovery and multi-version concurrency control etc.","title":"Why should you use this?"},{"location":"level101/databases_sql/innodb/#architecture","text":"","title":"Architecture"},{"location":"level101/databases_sql/innodb/#key-components","text":"Memory: Buffer pool: LRU cache of frequently used data(table and index) to be processed directly from memory, which speeds up processing. Important for tuning performance. Change buffer: Caches changes to secondary index pages when those pages are not in the buffer pool and merges it when they are fetched. Merging may take a long time and impact live queries. It also takes up part of the buffer pool. Avoids the extra I/O to read secondary indexes in. Adaptive hash index: Supplements InnoDB\u2019s B-Tree indexes with fast hash lookup tables like a cache. Slight performance penalty for misses, also adds maintenance overhead of updating it. Hash collisions cause AHI rebuilding for large DBs. Log buffer: Holds log data before flush to disk. Size of each above memory is configurable, and impacts performance a lot. Requires careful analysis of workload, available resources, benchmarking and tuning for optimal performance. Disk: Tables: Stores data within rows and columns. Indexes: Helps find rows with specific column values quickly, avoids full table scans. Redo Logs: all transactions are written to them, and after a crash, the recovery process corrects data written by incomplete transactions and replays any pending ones. Undo Logs: Records associated with a single transaction that contains information about how to undo the latest change by a transaction.","title":"Key components:"},{"location":"level101/databases_sql/intro/","text":"Relational Databases Prerequisites Complete Linux course Install Docker (for lab section) What to expect from this course You will have an understanding of what relational databases are, their advantages, and some MySQL specific concepts. What is not covered under this course In depth implementation details Advanced topics like normalization, sharding Specific tools for administration Introduction The main purpose of database systems is to manage data. This includes storage, adding new data, deleting unused data, updating existing data, retrieving data within a reasonable response time, other maintenance tasks to keep the system running etc. Pre-reads RDBMS Concepts Course Contents Key Concepts MySQL Architecture InnoDB Backup and Recovery MySQL Replication Operational Concepts SELECT Query Query Performance Lab Further Reading","title":"Introduction"},{"location":"level101/databases_sql/intro/#relational-databases","text":"","title":"Relational Databases"},{"location":"level101/databases_sql/intro/#prerequisites","text":"Complete Linux course Install Docker (for lab section)","title":"Prerequisites"},{"location":"level101/databases_sql/intro/#what-to-expect-from-this-course","text":"You will have an understanding of what relational databases are, their advantages, and some MySQL specific concepts.","title":"What to expect from this course"},{"location":"level101/databases_sql/intro/#what-is-not-covered-under-this-course","text":"In depth implementation details Advanced topics like normalization, sharding Specific tools for administration","title":"What is not covered under this course"},{"location":"level101/databases_sql/intro/#introduction","text":"The main purpose of database systems is to manage data. This includes storage, adding new data, deleting unused data, updating existing data, retrieving data within a reasonable response time, other maintenance tasks to keep the system running etc.","title":"Introduction"},{"location":"level101/databases_sql/intro/#pre-reads","text":"RDBMS Concepts","title":"Pre-reads"},{"location":"level101/databases_sql/intro/#course-contents","text":"Key Concepts MySQL Architecture InnoDB Backup and Recovery MySQL Replication Operational Concepts SELECT Query Query Performance Lab Further Reading","title":"Course Contents"},{"location":"level101/databases_sql/lab/","text":"Prerequisites Install Docker Setup Create a working directory named sos or something similar, and cd into it. Enter the following into a file named my.cnf under a directory named custom. sos $ cat custom/my.cnf [mysqld] # These settings apply to MySQL server # You can set port, socket path, buffer size etc. # Below, we are configuring slow query settings slow_query_log=1 slow_query_log_file=/var/log/mysqlslow.log long_query_time=1 Start a container and enable slow query log with the following: sos $ docker run --name db -v custom:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=realsecret -d mysql:8 sos $ docker cp custom/my.cnf $(docker ps -qf \"name=db\"):/etc/mysql/conf.d/custom.cnf sos $ docker restart $(docker ps -qf \"name=db\") Import a sample database sos $ git clone git@github.com:datacharmer/test_db.git sos $ docker cp test_db $(docker ps -qf \"name=db\"):/home/test_db/ sos $ docker exec -it $(docker ps -qf \"name=db\") bash root@3ab5b18b0c7d:/# cd /home/test_db/ root@3ab5b18b0c7d:/# mysql -uroot -prealsecret mysql < employees.sql root@3ab5b18b0c7d:/etc# touch /var/log/mysqlslow.log root@3ab5b18b0c7d:/etc# chown mysql:mysql /var/log/mysqlslow.log Workshop 1: Run some sample queries Run the following $ mysql -uroot -prealsecret mysql mysql> # inspect DBs and tables # the last 4 are MySQL internal DBs mysql> show databases; +--------------------+ | Database | +--------------------+ | employees | | information_schema | | mysql | | performance_schema | | sys | +--------------------+ > use employees; mysql> show tables; +----------------------+ | Tables_in_employees | +----------------------+ | current_dept_emp | | departments | | dept_emp | | dept_emp_latest_date | | dept_manager | | employees | | salaries | | titles | +----------------------+ # read a few rows mysql> select * from employees limit 5; # filter data by conditions mysql> select count(*) from employees where gender = 'M' limit 5; # find count of particular data mysql> select count(*) from employees where first_name = 'Sachin'; Workshop 2: Use explain and explain analyze to profile a query, identify and add indexes required for improving performance # View all indexes on table #(\\G is to output horizontally, replace it with a ; to get table output) mysql> show index from employees from employees\\G *************************** 1. row *************************** Table: employees Non_unique: 0 Key_name: PRIMARY Seq_in_index: 1 Column_name: emp_no Collation: A Cardinality: 299113 Sub_part: NULL Packed: NULL Null: Index_type: BTREE Comment: Index_comment: Visible: YES Expression: NULL # This query uses an index, idenitfied by 'key' field # By prefixing explain keyword to the command, # we get query plan (including key used) mysql> explain select * from employees where emp_no < 10005\\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: employees partitions: NULL type: range possible_keys: PRIMARY key: PRIMARY key_len: 4 ref: NULL rows: 4 filtered: 100.00 Extra: Using where # Compare that to the next query which does not utilize any index mysql> explain select first_name, last_name from employees where first_name = 'Sachin'\\G *************************** 1. row *************************** id: 1 select_type: SIMPLE table: employees partitions: NULL type: ALL possible_keys: NULL key: NULL key_len: NULL ref: NULL rows: 299113 filtered: 10.00 Extra: Using where # Let's see how much time this query takes mysql> explain analyze select first_name, last_name from employees where first_name = 'Sachin'\\G *************************** 1. row *************************** EXPLAIN: -> Filter: (employees.first_name = 'Sachin') (cost=30143.55 rows=29911) (actual time=28.284..3952.428 rows=232 loops=1) -> Table scan on employees (cost=30143.55 rows=299113) (actual time=0.095..1996.092 rows=300024 loops=1) # Cost(estimated by query planner) is 30143.55 # actual time=28.284ms for first row, 3952.428 for all rows # Now lets try adding an index and running the query again mysql> create index idx_firstname on employees(first_name); Query OK, 0 rows affected (1.25 sec) Records: 0 Duplicates: 0 Warnings: 0 mysql> explain analyze select first_name, last_name from employees where first_name = 'Sachin'; +--------------------------------------------------------------------------------------------------------------------------------------------+ | EXPLAIN | +--------------------------------------------------------------------------------------------------------------------------------------------+ | -> Index lookup on employees using idx_firstname (first_name='Sachin') (cost=81.20 rows=232) (actual time=0.551..2.934 rows=232 loops=1) | +--------------------------------------------------------------------------------------------------------------------------------------------+ 1 row in set (0.01 sec) # Actual time=0.551ms for first row # 2.934ms for all rows. A huge improvement! # Also notice that the query involves only an index lookup, # and no table scan (reading all rows of table) # ..which vastly reduces load on the DB. Workshop 3: Identify slow queries on a MySQL server # Run the command below in two terminal tabs to open two shells into the container. docker exec -it $(docker ps -qf \"name=db\") bash # Open a mysql prompt in one of them and execute this command # We have configured to log queries that take longer than 1s, # so this sleep(3) will be logged mysql -uroot -prealsecret mysql mysql> select sleep(3); # Now, in the other terminal, tail the slow log to find details about the query root@62c92c89234d:/etc# tail -f /var/log/mysqlslow.log /usr/sbin/mysqld, Version: 8.0.21 (MySQL Community Server - GPL). started with: Tcp port: 3306 Unix socket: /var/run/mysqld/mysqld.sock Time Id Command Argument # Time: 2020-11-26T14:53:44.822348Z # User@Host: root[root] @ localhost [] Id: 9 # Query_time: 5.404938 Lock_time: 0.000000 Rows_sent: 1 Rows_examined: 1 use employees; # Time: 2020-11-26T14:53:58.015736Z # User@Host: root[root] @ localhost [] Id: 9 # Query_time: 10.000225 Lock_time: 0.000000 Rows_sent: 1 Rows_examined: 1 SET timestamp=1606402428; select sleep(3); These were simulated examples with minimal complexity. In real life, the queries would be much more complex and the explain/analyze and slow query logs would have more details.","title":"Lab"},{"location":"level101/databases_sql/mysql/","text":"MySQL architecture MySQL architecture enables you to select the right storage engine for your needs, and abstracts away all implementation details from the end users (application engineers and DBA ) who only need to know a consistent stable API. Application layer: Connection handling - each client gets its own connection which is cached for the duration of access) Authentication - server checks (username,password,host) info of client and allows/rejects connection Security: server determines whether the client has privileges to execute each query (check with show privileges command) Server layer: Services and utilities - backup/restore, replication, cluster etc SQL interface - clients run queries for data access and manipulation SQL parser - creates a parse tree from the query (lexical/syntactic/semantic analysis and code generation) Optimizer - optimizes queries using various algorithms and data available to it(table level stats), modifies queries, order of scanning, indexes to use etc. (check with explain command) Caches and buffers - cache stores query results, buffer pool(InnoDB) stores table and index data in LRU fashion Storage engine options: InnoDB: most widely used, transaction support, ACID compliant, supports row-level locking, crash recovery and multi-version concurrency control. Default since MySQL 5.5+. MyISAM: fast, does not support transactions, provides table-level locking, great for read-heavy workloads, mostly in web and data warehousing. Default upto MySQL 5.1. Archive: optimised for high speed inserts, compresses data as it is inserted, does not support transactions, ideal for storing and retrieving large amounts of seldom referenced historical, archived data Memory: tables in memory. Fastest engine, supports table-level locking, does not support transactions, ideal for creating temporary tables or quick lookups, data is lost after a shutdown CSV: stores data in CSV files, great for integrating into other applications that use this format \u2026 etc. It is possible to migrate from one storage engine to another. But this migration locks tables for all operations and is not online, as it changes the physical layout of the data. It takes a long time and is generally not recommended. Hence, choosing the right storage engine at the beginning is important. General guideline is to use InnoDB unless you have a specific need for one of the other storage engines. Running mysql> SHOW ENGINES; shows you the supported engines on your MySQL server.","title":"MySQL"},{"location":"level101/databases_sql/mysql/#mysql-architecture","text":"MySQL architecture enables you to select the right storage engine for your needs, and abstracts away all implementation details from the end users (application engineers and DBA ) who only need to know a consistent stable API. Application layer: Connection handling - each client gets its own connection which is cached for the duration of access) Authentication - server checks (username,password,host) info of client and allows/rejects connection Security: server determines whether the client has privileges to execute each query (check with show privileges command) Server layer: Services and utilities - backup/restore, replication, cluster etc SQL interface - clients run queries for data access and manipulation SQL parser - creates a parse tree from the query (lexical/syntactic/semantic analysis and code generation) Optimizer - optimizes queries using various algorithms and data available to it(table level stats), modifies queries, order of scanning, indexes to use etc. (check with explain command) Caches and buffers - cache stores query results, buffer pool(InnoDB) stores table and index data in LRU fashion Storage engine options: InnoDB: most widely used, transaction support, ACID compliant, supports row-level locking, crash recovery and multi-version concurrency control. Default since MySQL 5.5+. MyISAM: fast, does not support transactions, provides table-level locking, great for read-heavy workloads, mostly in web and data warehousing. Default upto MySQL 5.1. Archive: optimised for high speed inserts, compresses data as it is inserted, does not support transactions, ideal for storing and retrieving large amounts of seldom referenced historical, archived data Memory: tables in memory. Fastest engine, supports table-level locking, does not support transactions, ideal for creating temporary tables or quick lookups, data is lost after a shutdown CSV: stores data in CSV files, great for integrating into other applications that use this format \u2026 etc. It is possible to migrate from one storage engine to another. But this migration locks tables for all operations and is not online, as it changes the physical layout of the data. It takes a long time and is generally not recommended. Hence, choosing the right storage engine at the beginning is important. General guideline is to use InnoDB unless you have a specific need for one of the other storage engines. Running mysql> SHOW ENGINES; shows you the supported engines on your MySQL server.","title":"MySQL architecture"},{"location":"level101/databases_sql/operations/","text":"Explain and explain+analyze EXPLAIN analyzes query plans from the optimizer, including how tables are joined, which tables/rows are scanned etc. Explain analyze shows the above and additional info like execution cost, number of rows returned, time taken etc. This knowledge is useful to tweak queries and add indexes. Watch this performance tuning tutorial video . Checkout the lab section for a hands-on about indexes. Slow query logs Used to identify slow queries (configurable threshold), enabled in config or dynamically with a query Checkout the lab section about identifying slow queries. User management This includes creation and changes to users, like managing privileges, changing password etc. Backup and restore strategies, pros and cons Logical backup using mysqldump - slower but can be done online Physical backup (copy data directory or use xtrabackup) - quick backup/recovery. Copying data directory requires locking or shut down. xtrabackup is an improvement because it supports backups without shutting down (hot backup). Others - PITR, snapshots etc. Crash recovery process using redo logs After a crash, when you restart server it reads redo logs and replays modifications to recover Monitoring MySQL Key MySQL metrics: reads, writes, query runtime, errors, slow queries, connections, running threads, InnoDB metrics Key OS metrics: CPU, load, memory, disk I/O, network Replication Copies data from one instance to one or more instances. Helps in horizontal scaling, data protection, analytics and performance. Binlog dump thread on primary, replication I/O and SQL threads on secondary. Strategies include the standard async, semi async or group replication. High Availability Ability to cope with failure at software, hardware and network level. Essential for anyone who needs 99.9%+ uptime. Can be implemented with replication or clustering solutions from MySQL, Percona, Oracle etc. Requires expertise to setup and maintain. Failover can be manual, scripted or using tools like Orchestrator. Data directory Data is stored in a particular directory, with nested directories for the data contained in each database. There are also MySQL log files, InnoDB log files, server process ID file and some other configs. The data directory is configurable. MySQL configuration This can be done by passing parameters during startup , or in a file . There are a few standard paths where MySQL looks for config files, /etc/my.cnf is one of the commonly used paths. These options are organized under headers (mysqld for server and mysql for client), you can explore them more in the lab that follows. Logs MySQL has logs for various purposes - general query log, errors, binary logs (for replication), slow query log. Only error log is enabled by default (to reduce I/O and storage requirement), the others can be enabled when required - by specifying config parameters at startup or running commands at runtime. Log destination can also be tweaked with config parameters.","title":"Operations"},{"location":"level101/databases_sql/query_performance/","text":"Query Performance Improvement Query Performance is a very crucial aspect of relational databases. If not tuned correctly, the select queries can become slow and painful for the application, and for the MySQL server as well. The important task is to identify the slow queries and try to improve their performance by either rewriting them or creating proper indexes on the tables involved in it. The Slow Query Log The slow query log contains SQL statements that take a longer time to execute then set in the config parameter long_query_time. These queries are the candidates for optimization. There are some good utilities to summarize the slow query logs like, mysqldumpslow (provided by MySQL itself), pt-query-digest (provided by Percona), etc. Following are the config parameters that are used to enable and effectively catch slow queries Variable Explanation Example value slow_query_log Enables or disables slow query logs ON slow_query_log_file The location of the slow query log /var/lib/mysql/mysql-slow.log long_query_time Threshold time. The query that takes longer than this time is logged in slow query log 5 log_queries_not_using_indexes When enabled with the slow query log, the queries which do not make use of any index are also logged in the slow query log even though they take less time than long_query_time. ON So, for this section, we will be enabling slow_query_log , long_query_time will be kept to 0.3 (300 ms) , and log_queries_not_using index will be enabled as well. Below are the queries that we will execute on the employees database. select * from employees where last_name = 'Koblick'; select * from salaries where salary >= 100000; select * from titles where title = 'Manager'; select * from employees where year(hire_date) = 1995; select year(e.hire_date), max(s.salary) from employees e join salaries s on e.emp_no=s.emp_no group by year(e.hire_date); Now, queries 1 , 3 and 4 executed under 300 ms but if we check the slow query logs, we will find these queries logged as they are not using any of the index. Queries 2 and 5 are taking longer than 300ms and also not using any index. Use the following command to get the summary of the slow query log mysqldumpslow /var/lib/mysql/mysql-slow.log There are some more queries in the snapshot that were along with the queries mentioned. Mysqldumpslow replaces actual values that were used by N (in case of numbers) and S (in case of strings). That can be overridden by -a option, however that will increase the output lines if different values are used in similar queries. The EXPLAIN Plan The EXPLAIN command is used with any query that we want to analyze. It describes the query execution plan, how MySQL sees and executes the query. EXPLAIN works with Select, Insert, Update and Delete statements. It tells about different aspects of the query like, how tables are joined, indexes used or not, etc. The important thing here is to understand the basic Explain plan output of a query to determine its performance. Let's take the following query as an example, mysql> explain select * from salaries where salary = 100000; +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ | 1 | SIMPLE | salaries | NULL | ALL | NULL | NULL | NULL | NULL | 2838426 | 10.00 | Using where | +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) The key aspects to understand in the above output are:- Partitions - the number of partitions considered while executing the query. It is only valid if the table is partitioned. Possible_keys - the list of indexes that were considered during creation of the execution plan. Key - the index that will be used while executing the query. Rows - the number of rows examined during the execution. Filtered - the percentage of rows that were filtered out of the rows examined. The maximum and most optimized result will have 100 in this field. Extra - this tells some extra information on how MySQL evaluates, whether the query is using only where clause to match target rows, any index or temporary table, etc. So, for the above query, we can determine that there are no partitions, there are no candidate indexes to be used and so no index is used at all, over 2M rows are examined and only 10% of them are included in the result, and lastly, only a where clause is used to match the target rows. Creating an Index Indexes are used to speed up selecting relevant rows for a given column value. Without an index, MySQL starts with the first row and goes through the entire table to find matching rows. If the table has too many rows, the operation becomes costly. With indexes, MySQL determines the position to start looking for the data without reading the full table. A primary key is also an index which is also the fastest and is stored along with the table data. Secondary indexes are stored outside of the table data and are used to further enhance the performance of SQL statements. Indexes are mostly stored as B-Trees, with some exceptions like spatial indexes use R-Trees and memory tables use hash indexes. There are 2 ways to create indexes:- While creating a table - if we know beforehand the columns that will drive the most number of where clauses in select queries, then we can put an index over them while creating a table. Altering a Table - To improve the performance of a troubling query, we create an index on a table which already has data in it using ALTER or CREATE INDEX command. This operation does not block the table but might take some time to complete depending on the size of the table. Let\u2019s look at the query that we discussed in the previous section. It\u2019s clear that scanning over 2M records is not a good idea when only 10% of those records are actually in the resultset. Hence, we create an index on the salary column of the salaries table. create index idx_salary on salaries(salary) OR alter table salaries add index idx_salary(salary) And the same explain plan now looks like this mysql> explain select * from salaries where salary = 100000; +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ | 1 | SIMPLE | salaries | NULL | ref | idx_salary | idx_salary | 4 | const | 13 | 100.00 | NULL | +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) Now the index used is idx_salary, the one we recently created. The index actually helped examine only 13 records and all of them are in the resultset. Also, the query execution time is also reduced from over 700ms to almost negligible. Let\u2019s look at another example. Here we are searching for a specific combination of first_name and last_name. But, we might also search based on last_name only. mysql> explain select * from employees where last_name = 'Dredge' and first_name = 'Yinghua'; +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | 1 | SIMPLE | employees | NULL | ALL | NULL | NULL | NULL | NULL | 299468 | 1.00 | Using where | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) Now only 1% record out of almost 300K is the resultset. Although the query time is particularly quick as we have only 300K records, this will be a pain if the number of records are over millions. In this case, we create an index on last_name and first_name, not separately, but a composite index including both the columns. create index idx_last_first on employees(last_name, first_name) mysql> explain select * from employees where last_name = 'Dredge' and first_name = 'Yinghua'; +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ | 1 | SIMPLE | employees | NULL | ref | idx_last_first | idx_last_first | 124 | const,const | 1 | 100.00 | NULL | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) We chose to put last_name before first_name while creating the index as the optimizer starts from the leftmost prefix of the index while evaluating the query. For example, if we have a 3-column index like idx(c1, c2, c3), then the search capability of the index follows - (c1), (c1, c2) or (c1, c2, c3) i.e. if your where clause has only first_name this index won\u2019t work. mysql> explain select * from employees where first_name = 'Yinghua'; +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | 1 | SIMPLE | employees | NULL | ALL | NULL | NULL | NULL | NULL | 299468 | 10.00 | Using where | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) But, if you have only the last_name in the where clause, it will work as expected. mysql> explain select * from employees where last_name = 'Dredge'; +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ | 1 | SIMPLE | employees | NULL | ref | idx_last_first | idx_last_first | 66 | const | 200 | 100.00 | NULL | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) For another example, use the following queries:- create table employees_2 like employees; create table salaries_2 like salaries; alter table salaries_2 drop primary key; We made copies of employees and salaries tables without the Primary Key of salaries table to understand an example of Select with Join. When you have queries like the below, it becomes tricky to identify the pain point of the query. mysql> select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; 1860 rows in set (4.44 sec) This query is taking about 4.5 seconds to complete with 1860 rows in the resultset. Let\u2019s look at the Explain plan. There will be 2 records in the Explain plan as 2 tables are used in the query. mysql> explain select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ | 1 | SIMPLE | s | NULL | ALL | NULL | NULL | NULL | NULL | 2837194 | 100.00 | NULL | | 1 | SIMPLE | e | NULL | eq_ref | PRIMARY,idx_last_first | PRIMARY | 4 | employees.s.emp_no | 1 | 5.00 | Using where | +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ 2 rows in set, 1 warning (0.00 sec) These are in order of evaluation i.e. salaries_2 will be evaluated first and then employees_2 will be joined to it. As it looks like, it scans almost all the rows of salaries_2 table and tries to match the employees_2 rows as per the join condition. Though where clause is used in fetching the final resultset, but the index corresponding to the where clause is not used for the employees_2 table. If the join is done on two indexes which have the same data-types, it will always be faster. So, let\u2019s create an index on the emp_no column of salaries_2 table and analyze the query again. create index idx_empno on salaries_2(emp_no); mysql> explain select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ | 1 | SIMPLE | e | NULL | ref | PRIMARY,idx_last_first | idx_last_first | 66 | const | 200 | 100.00 | NULL | | 1 | SIMPLE | s | NULL | ref | idx_empno | idx_empno | 4 | employees.e.emp_no | 9 | 100.00 | NULL | +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ 2 rows in set, 1 warning (0.00 sec) Now, not only did the index help the optimizer to examine only a few rows in both tables, it reversed the order of the tables in evaluation. The employees_2 table is evaluated first and rows are selected as per the index respective to the where clause. Then the records are joined to salaries_2 table as per the index used due to the join condition. The execution time of the query came down from 4.5s to 0.02s . mysql> select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'\\G 1860 rows in set (0.02 sec)","title":"Query Performance"},{"location":"level101/databases_sql/query_performance/#query-performance-improvement","text":"Query Performance is a very crucial aspect of relational databases. If not tuned correctly, the select queries can become slow and painful for the application, and for the MySQL server as well. The important task is to identify the slow queries and try to improve their performance by either rewriting them or creating proper indexes on the tables involved in it.","title":"Query Performance Improvement"},{"location":"level101/databases_sql/query_performance/#the-slow-query-log","text":"The slow query log contains SQL statements that take a longer time to execute then set in the config parameter long_query_time. These queries are the candidates for optimization. There are some good utilities to summarize the slow query logs like, mysqldumpslow (provided by MySQL itself), pt-query-digest (provided by Percona), etc. Following are the config parameters that are used to enable and effectively catch slow queries Variable Explanation Example value slow_query_log Enables or disables slow query logs ON slow_query_log_file The location of the slow query log /var/lib/mysql/mysql-slow.log long_query_time Threshold time. The query that takes longer than this time is logged in slow query log 5 log_queries_not_using_indexes When enabled with the slow query log, the queries which do not make use of any index are also logged in the slow query log even though they take less time than long_query_time. ON So, for this section, we will be enabling slow_query_log , long_query_time will be kept to 0.3 (300 ms) , and log_queries_not_using index will be enabled as well. Below are the queries that we will execute on the employees database. select * from employees where last_name = 'Koblick'; select * from salaries where salary >= 100000; select * from titles where title = 'Manager'; select * from employees where year(hire_date) = 1995; select year(e.hire_date), max(s.salary) from employees e join salaries s on e.emp_no=s.emp_no group by year(e.hire_date); Now, queries 1 , 3 and 4 executed under 300 ms but if we check the slow query logs, we will find these queries logged as they are not using any of the index. Queries 2 and 5 are taking longer than 300ms and also not using any index. Use the following command to get the summary of the slow query log mysqldumpslow /var/lib/mysql/mysql-slow.log There are some more queries in the snapshot that were along with the queries mentioned. Mysqldumpslow replaces actual values that were used by N (in case of numbers) and S (in case of strings). That can be overridden by -a option, however that will increase the output lines if different values are used in similar queries.","title":"The Slow Query Log"},{"location":"level101/databases_sql/query_performance/#the-explain-plan","text":"The EXPLAIN command is used with any query that we want to analyze. It describes the query execution plan, how MySQL sees and executes the query. EXPLAIN works with Select, Insert, Update and Delete statements. It tells about different aspects of the query like, how tables are joined, indexes used or not, etc. The important thing here is to understand the basic Explain plan output of a query to determine its performance. Let's take the following query as an example, mysql> explain select * from salaries where salary = 100000; +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ | 1 | SIMPLE | salaries | NULL | ALL | NULL | NULL | NULL | NULL | 2838426 | 10.00 | Using where | +----+-------------+----------+------------+------+---------------+------+---------+------+---------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) The key aspects to understand in the above output are:- Partitions - the number of partitions considered while executing the query. It is only valid if the table is partitioned. Possible_keys - the list of indexes that were considered during creation of the execution plan. Key - the index that will be used while executing the query. Rows - the number of rows examined during the execution. Filtered - the percentage of rows that were filtered out of the rows examined. The maximum and most optimized result will have 100 in this field. Extra - this tells some extra information on how MySQL evaluates, whether the query is using only where clause to match target rows, any index or temporary table, etc. So, for the above query, we can determine that there are no partitions, there are no candidate indexes to be used and so no index is used at all, over 2M rows are examined and only 10% of them are included in the result, and lastly, only a where clause is used to match the target rows.","title":"The EXPLAIN Plan"},{"location":"level101/databases_sql/query_performance/#creating-an-index","text":"Indexes are used to speed up selecting relevant rows for a given column value. Without an index, MySQL starts with the first row and goes through the entire table to find matching rows. If the table has too many rows, the operation becomes costly. With indexes, MySQL determines the position to start looking for the data without reading the full table. A primary key is also an index which is also the fastest and is stored along with the table data. Secondary indexes are stored outside of the table data and are used to further enhance the performance of SQL statements. Indexes are mostly stored as B-Trees, with some exceptions like spatial indexes use R-Trees and memory tables use hash indexes. There are 2 ways to create indexes:- While creating a table - if we know beforehand the columns that will drive the most number of where clauses in select queries, then we can put an index over them while creating a table. Altering a Table - To improve the performance of a troubling query, we create an index on a table which already has data in it using ALTER or CREATE INDEX command. This operation does not block the table but might take some time to complete depending on the size of the table. Let\u2019s look at the query that we discussed in the previous section. It\u2019s clear that scanning over 2M records is not a good idea when only 10% of those records are actually in the resultset. Hence, we create an index on the salary column of the salaries table. create index idx_salary on salaries(salary) OR alter table salaries add index idx_salary(salary) And the same explain plan now looks like this mysql> explain select * from salaries where salary = 100000; +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ | 1 | SIMPLE | salaries | NULL | ref | idx_salary | idx_salary | 4 | const | 13 | 100.00 | NULL | +----+-------------+----------+------------+------+---------------+------------+---------+-------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) Now the index used is idx_salary, the one we recently created. The index actually helped examine only 13 records and all of them are in the resultset. Also, the query execution time is also reduced from over 700ms to almost negligible. Let\u2019s look at another example. Here we are searching for a specific combination of first_name and last_name. But, we might also search based on last_name only. mysql> explain select * from employees where last_name = 'Dredge' and first_name = 'Yinghua'; +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | 1 | SIMPLE | employees | NULL | ALL | NULL | NULL | NULL | NULL | 299468 | 1.00 | Using where | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) Now only 1% record out of almost 300K is the resultset. Although the query time is particularly quick as we have only 300K records, this will be a pain if the number of records are over millions. In this case, we create an index on last_name and first_name, not separately, but a composite index including both the columns. create index idx_last_first on employees(last_name, first_name) mysql> explain select * from employees where last_name = 'Dredge' and first_name = 'Yinghua'; +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ | 1 | SIMPLE | employees | NULL | ref | idx_last_first | idx_last_first | 124 | const,const | 1 | 100.00 | NULL | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) We chose to put last_name before first_name while creating the index as the optimizer starts from the leftmost prefix of the index while evaluating the query. For example, if we have a 3-column index like idx(c1, c2, c3), then the search capability of the index follows - (c1), (c1, c2) or (c1, c2, c3) i.e. if your where clause has only first_name this index won\u2019t work. mysql> explain select * from employees where first_name = 'Yinghua'; +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ | 1 | SIMPLE | employees | NULL | ALL | NULL | NULL | NULL | NULL | 299468 | 10.00 | Using where | +----+-------------+-----------+------------+------+---------------+------+---------+------+--------+----------+-------------+ 1 row in set, 1 warning (0.00 sec) But, if you have only the last_name in the where clause, it will work as expected. mysql> explain select * from employees where last_name = 'Dredge'; +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ | 1 | SIMPLE | employees | NULL | ref | idx_last_first | idx_last_first | 66 | const | 200 | 100.00 | NULL | +----+-------------+-----------+------------+------+----------------+----------------+---------+-------+------+----------+-------+ 1 row in set, 1 warning (0.00 sec) For another example, use the following queries:- create table employees_2 like employees; create table salaries_2 like salaries; alter table salaries_2 drop primary key; We made copies of employees and salaries tables without the Primary Key of salaries table to understand an example of Select with Join. When you have queries like the below, it becomes tricky to identify the pain point of the query. mysql> select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; 1860 rows in set (4.44 sec) This query is taking about 4.5 seconds to complete with 1860 rows in the resultset. Let\u2019s look at the Explain plan. There will be 2 records in the Explain plan as 2 tables are used in the query. mysql> explain select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ | 1 | SIMPLE | s | NULL | ALL | NULL | NULL | NULL | NULL | 2837194 | 100.00 | NULL | | 1 | SIMPLE | e | NULL | eq_ref | PRIMARY,idx_last_first | PRIMARY | 4 | employees.s.emp_no | 1 | 5.00 | Using where | +----+-------------+-------+------------+--------+------------------------+---------+---------+--------------------+---------+----------+-------------+ 2 rows in set, 1 warning (0.00 sec) These are in order of evaluation i.e. salaries_2 will be evaluated first and then employees_2 will be joined to it. As it looks like, it scans almost all the rows of salaries_2 table and tries to match the employees_2 rows as per the join condition. Though where clause is used in fetching the final resultset, but the index corresponding to the where clause is not used for the employees_2 table. If the join is done on two indexes which have the same data-types, it will always be faster. So, let\u2019s create an index on the emp_no column of salaries_2 table and analyze the query again. create index idx_empno on salaries_2(emp_no); mysql> explain select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'; +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ | 1 | SIMPLE | e | NULL | ref | PRIMARY,idx_last_first | idx_last_first | 66 | const | 200 | 100.00 | NULL | | 1 | SIMPLE | s | NULL | ref | idx_empno | idx_empno | 4 | employees.e.emp_no | 9 | 100.00 | NULL | +----+-------------+-------+------------+------+------------------------+----------------+---------+--------------------+------+----------+-------+ 2 rows in set, 1 warning (0.00 sec) Now, not only did the index help the optimizer to examine only a few rows in both tables, it reversed the order of the tables in evaluation. The employees_2 table is evaluated first and rows are selected as per the index respective to the where clause. Then the records are joined to salaries_2 table as per the index used due to the join condition. The execution time of the query came down from 4.5s to 0.02s . mysql> select e.first_name, e.last_name, s.salary, e.hire_date from employees_2 e join salaries_2 s on e.emp_no=s.emp_no where e.last_name='Dredge'\\G 1860 rows in set (0.02 sec)","title":"Creating an Index"},{"location":"level101/databases_sql/replication/","text":"MySQL Replication Replication enables data from one MySQL host (termed as Primary) to be copied to another MySQL host (termed as Replica). MySQL Replication is asynchronous in nature by default, but it can be changed to semi-synchronous with some configurations. Some common applications of MySQL replication are:- Read-scaling - as multiple hosts can replicate the data from a single primary host, we can set up as many replicas as we need and scale reads through them, i.e. application writes will go to a single primary host and the reads can balance between all the replicas that are there. Such a setup can improve the write performance as well, as the primary is dedicated to only updates and not reads. Backups using replicas - the backup process can sometimes be a little heavy. But if we have replicas configured, then we can use one of them to get the backup without affecting the primary data at all. Disaster Recovery - a replica in some other geographical region paves a proper path to configure disaster recovery. MySQL supports different types of synchronizations as well:- Asynchronous - this is the default synchronization method. It is one-way, i.e. one host serves as primary and one or more hosts as replica. We will discuss this method throughout the replication topic. Semi-Synchronous - in this type of synchronization, a commit performed on the primary host is blocked until at least one replica acknowledges it. Post the acknowledgement from any one replica, the control is returned to the session that performed the transaction. This ensures strong consistency but the replication is slower than asynchronous. Delayed - we can deliberately lag the replica in a typical MySQL replication by the number of seconds desired by the use case. This type of replication safeguards from severe human errors of dropping or corrupting the data on the primary, for example, in the above diagram for Delayed Replication, if a DROP DATABASE is executed by mistake on the primary, we still have 30 minutes to recover the data from R2 as that command has not been replicated on R2 yet. Pre-Requisites Before we dive into setting up replication, we should know about the binary logs. Binary logs play a very important role in MySQL replication. Binary logs, or commonly known as binlogs contain events about the changes done to the database, like table structure changes, data changes via DML operations, etc. They are not used to log SELECT statements. For replication, the primary sends the information to the replicas using its binlogs about the changes done to the database, and the replicas make the same data changes. With respect to MySQL replication, the binary log format can be of two types that decides the main type of replication:- - Statement-Based Replication or SBR - Row-Based Replication or RBR Statement Based Binlog Format Originally, the replication in MySQL was based on SQL statements getting replicated and executed on the replica from the primary. This is called statement based logging. The binlog contains the exact SQL statement run by the session. So If we run the above statements to insert 3 records and the update 3 in a single update statement, they will be logged exactly the same as when we executed them. Row Based Binlog Format The Row based is the default one in the latest MySQL releases. This is a lot different from the Statement format as here, row events are logged instead of statements. By that we mean, in the above example one update statement affected 3 records, but binlog had only one update statement; if it is a row based format, binlog will have an event for each record updated. Statement Based v/s Row Based binlogs Let\u2019s have a look at the operational differences between statement-based and row-based binlogs. Statement Based Row Based Logs SQL statements as executed Logs row events based on SQL statements executed Takes lesser disk space Takes more disk space Restoring using binlogs is faster Restoring using binlogs is slower When used for replication, if any statement has a predefined function that has its own value, like sysdate(), uuid() etc, the output could be different on the replica which makes it inconsistent. Whatever is executed becomes a row event with values, so there will be no problem if such functions are used in SQL statements. Only statements are logged so no other row events are generated. A lot of events are generated when a table is copied into another using INSERT INTO SELECT. Note - There is another type of binlog format called Mixed . With mixed logging, statement based is used by default but it switches to row based in certain cases. If MySQL cannot guarantee that statement based logging is safe for the statements executed, it issues a warning and switches to row based for those statements. We will be using binary log format as Row for the entire replication topic. Replication in Motion The above figure indicates how a typical MySQL replication works. Replica_IO_Thread is responsible to fetch the binlog events from the primary binary logs to the replica On the Replica host, relay logs are created which are exact copies of the binary logs. If the binary logs on primary are in row format, the relay logs will be the same. Replica_SQL_Thread applies the relay logs on the replica MySQL server. If log-bin is enabled on the replica, then the replica will have its own binary logs as well. If log-slave-updates is enabled, then it will have the updates from the primary logged in the binlogs as well. Setting up Replication In this section, we will set up a simple asynchronous replication. The binlogs will be in row based format. The replication will be set up on two fresh hosts with no prior data present. There are two different ways in which we can set up replication. Binlog based - Each replica keeps a record of the binlog coordinates on the primary - current binlog and position in the binlog till where it has read and processed. So, at a time different replicas might be reading different parts of the same binlog. GTID based - Every transaction gets an identifier called global transaction identifier or GTID. There is no need to keep the record of binlog coordinates, as long as the replica has all the GTIDs executed on the primary, it is consistent with the primary. A typical GTID is the server_uuid:# positive integer. We will set up a GTID based replication in the following section but will also discuss binlog based replication setup as well. Primary Host Configurations The following config parameters should be present in the primary my.cnf file for setting up GTID based replication. server-id - a unique ID for the mysql server log-bin - the binlog location binlog-format - ROW | STATEMENT (we will use ROW) gtid-mode - ON enforce-gtid-consistency - ON (allows execution of only those statements which can be logged using GTIDs) Replica Host Configurations The following config parameters should be present in the replica my.cnf file for setting up replication. server-id - different than the primary host log-bin - (optional, if you want replica to log its own changes as well) binlog-format - depends on the above gtid-mode - ON enforce-gtid-consistency - ON log-slave-updates - ON (if binlog is enabled, then we can enable this. This enables the replica to log the changes coming from the primary along with its own changes. Helps in setting up chain replication) Replication User Every replica connects to the primary using a mysql user for replicating. So there must be a mysql user account for the same on the primary host. Any user can be used for this purpose provided it has REPLICATION SLAVE privilege. If the sole purpose is replication then we can have a user with only the required privilege. On the primary host mysql> create user repl_user@ identified by 'xxxxx'; mysql> grant replication slave on *.* to repl_user@''; Obtaining Starting position from Primary Run the following command on the primary host mysql> show master status\\G *************************** 1. row *************************** File: mysql-bin.000001 Position: 73 Binlog_Do_DB: Binlog_Ignore_DB: Executed_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 1 row in set (0.00 sec) If we are working with binary log based replication, the top two output lines are the most important ones. That tells the current binlog on the primary host and till what position it has written. For fresh hosts we know that no data is written so we can directly set up replication using the very first binlog file and position 4. If we are setting up a replication from a backup, then that changes the way we obtain the starting position. For GTIDs, the executed_gtid_set is the value where primary is right now. Again, for a fresh setup, we don\u2019t have to specify anything about the starting point and it will start from the transaction id 1, but when we set up from a backup, the backup will contain the GTID positions till where backup has been taken. Setting up Replica The replication setup must know about the primary host, the user and password to connect, the binlog coordinates (for binlog based replication) or the GTID auto-position parameter. The following command is used for setting up change master to master_host = '', master_port = , master_user = 'repl_user', master_password = 'xxxxx', master_auto_position = 1; Note - the Change Master To command has been replaced with Change Replication Source To from Mysql 8.0.23 onwards, also all the master and slave keywords are replaced with source and replica . If it is binlog based replication, then instead of master_auto_position, we need to specify the binlog coordinates. master_log_file = 'mysql-bin.000001', master_log_pos = 4 Starting Replication and Check Status Now that everything is configured, we just need to start the replication on the replica via the following command start slave; OR from MySQL 8.0.23 onwards, start replica; Whether or not the replication is running successfully, we can determine by running the following command show slave status\\G OR from MySQL 8.0.23 onwards, show replica status\\G mysql> show replica status\\G *************************** 1. row *************************** Replica_IO_State: Waiting for master to send event Source_Host: Source_User: repl_user Source_Port: Connect_Retry: 60 Source_Log_File: mysql-bin.000001 Read_Source_Log_Pos: 852 Relay_Log_File: mysql-relay-bin.000002 Relay_Log_Pos: 1067 Relay_Source_Log_File: mysql-bin.000001 Replica_IO_Running: Yes Replica_SQL_Running: Yes Replicate_Do_DB: Replicate_Ignore_DB: Replicate_Do_Table: Replicate_Ignore_Table: Replicate_Wild_Do_Table: Replicate_Wild_Ignore_Table: Last_Errno: 0 Last_Error: Skip_Counter: 0 Exec_Source_Log_Pos: 852 Relay_Log_Space: 1283 Until_Condition: None Until_Log_File: Until_Log_Pos: 0 Source_SSL_Allowed: No Source_SSL_CA_File: Source_SSL_CA_Path: Source_SSL_Cert: Source_SSL_Cipher: Source_SSL_Key: Seconds_Behind_Source: 0 Source_SSL_Verify_Server_Cert: No Last_IO_Errno: 0 Last_IO_Error: Last_SQL_Errno: 0 Last_SQL_Error: Replicate_Ignore_Server_Ids: Source_Server_Id: 1 Source_UUID: e17d0920-d00e-11eb-a3e6-000d3aa00f87 Source_Info_File: mysql.slave_master_info SQL_Delay: 0 SQL_Remaining_Delay: NULL Replica_SQL_Running_State: Slave has read all relay log; waiting for more updates Source_Retry_Count: 86400 Source_Bind: Last_IO_Error_Timestamp: Last_SQL_Error_Timestamp: Source_SSL_Crl: Source_SSL_Crlpath: Retrieved_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 Executed_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 Auto_Position: 1 Replicate_Rewrite_DB: Channel_Name: Source_TLS_Version: Source_public_key_path: Get_Source_public_key: 0 Network_Namespace: 1 row in set (0.00 sec) Some of the parameters are explained below:- Relay_Source_Log_File - the primary\u2019s file where replica is currently reading from Execute_Source_Log_Pos - for the above file on which position is the replica reading currently from. These two parameters are of utmost importance when binlog based replication is used. Replica_IO_Running - IO thread of replica is running or not Replica_SQL_Running - SQL thread of replica is running or not Seconds_Behind_Source - the difference of seconds when a statement was executed on Primary and then on Replica. This indicates how much replication lag is there. Source_UUID - the uuid of the primary host Retrieved_Gtid_Set - the GTIDs fetched from the primary host by the replica to be executed. Executed_Gtid_Set - the GTIDs executed on the replica. This set remains the same for the entire cluster if the replicas are in sync. Auto_Position - it directs the replica to fetch the next GTID automatically Create a Replica for the already setup cluster The steps discussed in the previous section talks about the setting up replication on two fresh hosts. When we have to set up a replica for a host which is already serving applications, then the backup of the primary is used, either fresh backup taken for the replica (should only be done if the traffic it is serving is less) or use a recently taken backup. If the size of the databases on the MySQL primary server is small, less than 100G recommended, then mysqldump can be used to take backup along with the following options. mysqldump -uroot -p -hhost_ip -P3306 --all-databases --single-transaction --master-data=1 > primary_host.bkp --single-transaction - this option starts a transaction before taking the backup which ensures it is consistent. As transactions are isolated from each other, so no other writes affect the backup. --master-data - this option is required if binlog based replication is desired to be set up. It includes the binary log file and log file position in the backup file. When GTID mode is enabled and mysqldump is executed, it includes the GTID executed to be used to start the replica after the backup position. The contents of the mysqldump output file will have the following It is recommended to comment these before restoring otherwise they could throw errors. Also, using master-data=2 will automatically comment the master_log_file line. Similarly, when taking backup of the host using xtrabackup , the file xtrabckup_info file contains the information about binlog file and file position, as well as the GTID executed set. server_version = 8.0.25 start_time = 2021-06-22 03:45:17 end_time = 2021-06-22 03:45:20 lock_time = 0 binlog_pos = filename 'mysql-bin.000007', position '196', GTID of the last change 'e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-5' innodb_from_lsn = 0 innodb_to_lsn = 18153149 partial = N incremental = N format = file compressed = N encrypted = N Now, after setting MySQL server on the desired host, restore the backup taken from any one of the above methods. If the intended way is binlog based replication, then use the binlog file and position info in the following command change Replication Source to source_host = \u2018primary_ip\u2019, source_port = 3306, source_user = \u2018repl_user\u2019, source_password = \u2018xxxxx\u2019, source_log_file = \u2018mysql-bin.000007\u2019, source_log_pos = \u2018196\u2019; If the replication needs to be set via GITDs, then run the below command to tell the replica about the GTIDs already executed. On the Replica host, run th following commands reset master; set global gtid_purged = \u2018e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-5\u2019 change replication source to source_host = \u2018primary_ip\u2019, source_port = 3306, source_user = \u2018repl_user\u2019, source_password = \u2018xxxxx\u2019, source_auto_position = 1 The reset master command resets the position of the binary log to initial. It can be skipped if the host is a freshly installed MySQL, but we restored a backup so it is necessary. The gtid_purged global variable lets the replica know the GTIDs that have already been executed, so that the replication can start after that. Then in the change source command, we set the auto-position to 1 which automatically gets the next GTID to proceed. Further Reading More applications of Replication Automtaed Failovers using MySQL Orchestrator","title":"MySQL Replication"},{"location":"level101/databases_sql/replication/#mysql-replication","text":"Replication enables data from one MySQL host (termed as Primary) to be copied to another MySQL host (termed as Replica). MySQL Replication is asynchronous in nature by default, but it can be changed to semi-synchronous with some configurations. Some common applications of MySQL replication are:- Read-scaling - as multiple hosts can replicate the data from a single primary host, we can set up as many replicas as we need and scale reads through them, i.e. application writes will go to a single primary host and the reads can balance between all the replicas that are there. Such a setup can improve the write performance as well, as the primary is dedicated to only updates and not reads. Backups using replicas - the backup process can sometimes be a little heavy. But if we have replicas configured, then we can use one of them to get the backup without affecting the primary data at all. Disaster Recovery - a replica in some other geographical region paves a proper path to configure disaster recovery. MySQL supports different types of synchronizations as well:- Asynchronous - this is the default synchronization method. It is one-way, i.e. one host serves as primary and one or more hosts as replica. We will discuss this method throughout the replication topic. Semi-Synchronous - in this type of synchronization, a commit performed on the primary host is blocked until at least one replica acknowledges it. Post the acknowledgement from any one replica, the control is returned to the session that performed the transaction. This ensures strong consistency but the replication is slower than asynchronous. Delayed - we can deliberately lag the replica in a typical MySQL replication by the number of seconds desired by the use case. This type of replication safeguards from severe human errors of dropping or corrupting the data on the primary, for example, in the above diagram for Delayed Replication, if a DROP DATABASE is executed by mistake on the primary, we still have 30 minutes to recover the data from R2 as that command has not been replicated on R2 yet. Pre-Requisites Before we dive into setting up replication, we should know about the binary logs. Binary logs play a very important role in MySQL replication. Binary logs, or commonly known as binlogs contain events about the changes done to the database, like table structure changes, data changes via DML operations, etc. They are not used to log SELECT statements. For replication, the primary sends the information to the replicas using its binlogs about the changes done to the database, and the replicas make the same data changes. With respect to MySQL replication, the binary log format can be of two types that decides the main type of replication:- - Statement-Based Replication or SBR - Row-Based Replication or RBR Statement Based Binlog Format Originally, the replication in MySQL was based on SQL statements getting replicated and executed on the replica from the primary. This is called statement based logging. The binlog contains the exact SQL statement run by the session. So If we run the above statements to insert 3 records and the update 3 in a single update statement, they will be logged exactly the same as when we executed them. Row Based Binlog Format The Row based is the default one in the latest MySQL releases. This is a lot different from the Statement format as here, row events are logged instead of statements. By that we mean, in the above example one update statement affected 3 records, but binlog had only one update statement; if it is a row based format, binlog will have an event for each record updated. Statement Based v/s Row Based binlogs Let\u2019s have a look at the operational differences between statement-based and row-based binlogs. Statement Based Row Based Logs SQL statements as executed Logs row events based on SQL statements executed Takes lesser disk space Takes more disk space Restoring using binlogs is faster Restoring using binlogs is slower When used for replication, if any statement has a predefined function that has its own value, like sysdate(), uuid() etc, the output could be different on the replica which makes it inconsistent. Whatever is executed becomes a row event with values, so there will be no problem if such functions are used in SQL statements. Only statements are logged so no other row events are generated. A lot of events are generated when a table is copied into another using INSERT INTO SELECT. Note - There is another type of binlog format called Mixed . With mixed logging, statement based is used by default but it switches to row based in certain cases. If MySQL cannot guarantee that statement based logging is safe for the statements executed, it issues a warning and switches to row based for those statements. We will be using binary log format as Row for the entire replication topic. Replication in Motion The above figure indicates how a typical MySQL replication works. Replica_IO_Thread is responsible to fetch the binlog events from the primary binary logs to the replica On the Replica host, relay logs are created which are exact copies of the binary logs. If the binary logs on primary are in row format, the relay logs will be the same. Replica_SQL_Thread applies the relay logs on the replica MySQL server. If log-bin is enabled on the replica, then the replica will have its own binary logs as well. If log-slave-updates is enabled, then it will have the updates from the primary logged in the binlogs as well.","title":"MySQL Replication"},{"location":"level101/databases_sql/replication/#setting-up-replication","text":"In this section, we will set up a simple asynchronous replication. The binlogs will be in row based format. The replication will be set up on two fresh hosts with no prior data present. There are two different ways in which we can set up replication. Binlog based - Each replica keeps a record of the binlog coordinates on the primary - current binlog and position in the binlog till where it has read and processed. So, at a time different replicas might be reading different parts of the same binlog. GTID based - Every transaction gets an identifier called global transaction identifier or GTID. There is no need to keep the record of binlog coordinates, as long as the replica has all the GTIDs executed on the primary, it is consistent with the primary. A typical GTID is the server_uuid:# positive integer. We will set up a GTID based replication in the following section but will also discuss binlog based replication setup as well. Primary Host Configurations The following config parameters should be present in the primary my.cnf file for setting up GTID based replication. server-id - a unique ID for the mysql server log-bin - the binlog location binlog-format - ROW | STATEMENT (we will use ROW) gtid-mode - ON enforce-gtid-consistency - ON (allows execution of only those statements which can be logged using GTIDs) Replica Host Configurations The following config parameters should be present in the replica my.cnf file for setting up replication. server-id - different than the primary host log-bin - (optional, if you want replica to log its own changes as well) binlog-format - depends on the above gtid-mode - ON enforce-gtid-consistency - ON log-slave-updates - ON (if binlog is enabled, then we can enable this. This enables the replica to log the changes coming from the primary along with its own changes. Helps in setting up chain replication) Replication User Every replica connects to the primary using a mysql user for replicating. So there must be a mysql user account for the same on the primary host. Any user can be used for this purpose provided it has REPLICATION SLAVE privilege. If the sole purpose is replication then we can have a user with only the required privilege. On the primary host mysql> create user repl_user@ identified by 'xxxxx'; mysql> grant replication slave on *.* to repl_user@''; Obtaining Starting position from Primary Run the following command on the primary host mysql> show master status\\G *************************** 1. row *************************** File: mysql-bin.000001 Position: 73 Binlog_Do_DB: Binlog_Ignore_DB: Executed_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 1 row in set (0.00 sec) If we are working with binary log based replication, the top two output lines are the most important ones. That tells the current binlog on the primary host and till what position it has written. For fresh hosts we know that no data is written so we can directly set up replication using the very first binlog file and position 4. If we are setting up a replication from a backup, then that changes the way we obtain the starting position. For GTIDs, the executed_gtid_set is the value where primary is right now. Again, for a fresh setup, we don\u2019t have to specify anything about the starting point and it will start from the transaction id 1, but when we set up from a backup, the backup will contain the GTID positions till where backup has been taken. Setting up Replica The replication setup must know about the primary host, the user and password to connect, the binlog coordinates (for binlog based replication) or the GTID auto-position parameter. The following command is used for setting up change master to master_host = '', master_port = , master_user = 'repl_user', master_password = 'xxxxx', master_auto_position = 1; Note - the Change Master To command has been replaced with Change Replication Source To from Mysql 8.0.23 onwards, also all the master and slave keywords are replaced with source and replica . If it is binlog based replication, then instead of master_auto_position, we need to specify the binlog coordinates. master_log_file = 'mysql-bin.000001', master_log_pos = 4 Starting Replication and Check Status Now that everything is configured, we just need to start the replication on the replica via the following command start slave; OR from MySQL 8.0.23 onwards, start replica; Whether or not the replication is running successfully, we can determine by running the following command show slave status\\G OR from MySQL 8.0.23 onwards, show replica status\\G mysql> show replica status\\G *************************** 1. row *************************** Replica_IO_State: Waiting for master to send event Source_Host: Source_User: repl_user Source_Port: Connect_Retry: 60 Source_Log_File: mysql-bin.000001 Read_Source_Log_Pos: 852 Relay_Log_File: mysql-relay-bin.000002 Relay_Log_Pos: 1067 Relay_Source_Log_File: mysql-bin.000001 Replica_IO_Running: Yes Replica_SQL_Running: Yes Replicate_Do_DB: Replicate_Ignore_DB: Replicate_Do_Table: Replicate_Ignore_Table: Replicate_Wild_Do_Table: Replicate_Wild_Ignore_Table: Last_Errno: 0 Last_Error: Skip_Counter: 0 Exec_Source_Log_Pos: 852 Relay_Log_Space: 1283 Until_Condition: None Until_Log_File: Until_Log_Pos: 0 Source_SSL_Allowed: No Source_SSL_CA_File: Source_SSL_CA_Path: Source_SSL_Cert: Source_SSL_Cipher: Source_SSL_Key: Seconds_Behind_Source: 0 Source_SSL_Verify_Server_Cert: No Last_IO_Errno: 0 Last_IO_Error: Last_SQL_Errno: 0 Last_SQL_Error: Replicate_Ignore_Server_Ids: Source_Server_Id: 1 Source_UUID: e17d0920-d00e-11eb-a3e6-000d3aa00f87 Source_Info_File: mysql.slave_master_info SQL_Delay: 0 SQL_Remaining_Delay: NULL Replica_SQL_Running_State: Slave has read all relay log; waiting for more updates Source_Retry_Count: 86400 Source_Bind: Last_IO_Error_Timestamp: Last_SQL_Error_Timestamp: Source_SSL_Crl: Source_SSL_Crlpath: Retrieved_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 Executed_Gtid_Set: e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-3 Auto_Position: 1 Replicate_Rewrite_DB: Channel_Name: Source_TLS_Version: Source_public_key_path: Get_Source_public_key: 0 Network_Namespace: 1 row in set (0.00 sec) Some of the parameters are explained below:- Relay_Source_Log_File - the primary\u2019s file where replica is currently reading from Execute_Source_Log_Pos - for the above file on which position is the replica reading currently from. These two parameters are of utmost importance when binlog based replication is used. Replica_IO_Running - IO thread of replica is running or not Replica_SQL_Running - SQL thread of replica is running or not Seconds_Behind_Source - the difference of seconds when a statement was executed on Primary and then on Replica. This indicates how much replication lag is there. Source_UUID - the uuid of the primary host Retrieved_Gtid_Set - the GTIDs fetched from the primary host by the replica to be executed. Executed_Gtid_Set - the GTIDs executed on the replica. This set remains the same for the entire cluster if the replicas are in sync. Auto_Position - it directs the replica to fetch the next GTID automatically Create a Replica for the already setup cluster The steps discussed in the previous section talks about the setting up replication on two fresh hosts. When we have to set up a replica for a host which is already serving applications, then the backup of the primary is used, either fresh backup taken for the replica (should only be done if the traffic it is serving is less) or use a recently taken backup. If the size of the databases on the MySQL primary server is small, less than 100G recommended, then mysqldump can be used to take backup along with the following options. mysqldump -uroot -p -hhost_ip -P3306 --all-databases --single-transaction --master-data=1 > primary_host.bkp --single-transaction - this option starts a transaction before taking the backup which ensures it is consistent. As transactions are isolated from each other, so no other writes affect the backup. --master-data - this option is required if binlog based replication is desired to be set up. It includes the binary log file and log file position in the backup file. When GTID mode is enabled and mysqldump is executed, it includes the GTID executed to be used to start the replica after the backup position. The contents of the mysqldump output file will have the following It is recommended to comment these before restoring otherwise they could throw errors. Also, using master-data=2 will automatically comment the master_log_file line. Similarly, when taking backup of the host using xtrabackup , the file xtrabckup_info file contains the information about binlog file and file position, as well as the GTID executed set. server_version = 8.0.25 start_time = 2021-06-22 03:45:17 end_time = 2021-06-22 03:45:20 lock_time = 0 binlog_pos = filename 'mysql-bin.000007', position '196', GTID of the last change 'e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-5' innodb_from_lsn = 0 innodb_to_lsn = 18153149 partial = N incremental = N format = file compressed = N encrypted = N Now, after setting MySQL server on the desired host, restore the backup taken from any one of the above methods. If the intended way is binlog based replication, then use the binlog file and position info in the following command change Replication Source to source_host = \u2018primary_ip\u2019, source_port = 3306, source_user = \u2018repl_user\u2019, source_password = \u2018xxxxx\u2019, source_log_file = \u2018mysql-bin.000007\u2019, source_log_pos = \u2018196\u2019; If the replication needs to be set via GITDs, then run the below command to tell the replica about the GTIDs already executed. On the Replica host, run th following commands reset master; set global gtid_purged = \u2018e17d0920-d00e-11eb-a3e6-000d3aa00f87:1-5\u2019 change replication source to source_host = \u2018primary_ip\u2019, source_port = 3306, source_user = \u2018repl_user\u2019, source_password = \u2018xxxxx\u2019, source_auto_position = 1 The reset master command resets the position of the binary log to initial. It can be skipped if the host is a freshly installed MySQL, but we restored a backup so it is necessary. The gtid_purged global variable lets the replica know the GTIDs that have already been executed, so that the replication can start after that. Then in the change source command, we set the auto-position to 1 which automatically gets the next GTID to proceed.","title":"Setting up Replication"},{"location":"level101/databases_sql/replication/#further-reading","text":"More applications of Replication Automtaed Failovers using MySQL Orchestrator","title":"Further Reading"},{"location":"level101/databases_sql/select_query/","text":"SELECT Query The most commonly used command while working with MySQL is SELECT. It is used to fetch the result set from one or more tables. The general form of a typical select query looks like:- SELECT expr FROM table1 [WHERE condition] [GROUP BY column_list HAVING condition] [ORDER BY column_list ASC|DESC] [LIMIT #] The above general form contains some commonly used clauses of a SELECT query:- expr - comma-separated column list or * (for all columns) WHERE - a condition is provided, if true, directs the query to select only those records. GROUP BY - groups the entire result set based on the column list provided. An aggregate function is recommended to be present in the select expression of the query. HAVING supports grouping by putting a condition on the selected or any other aggregate function. ORDER BY - sorts the result set based on the column list in ascending or descending order. LIMIT - commonly used to limit the number of records. Let\u2019s have a look at some examples for a better understanding of the above. The dataset used for the examples below is available here and is free to use. Select all records mysql> select * from employees limit 5; +--------+------------+------------+-----------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-----------+--------+------------+ | 10001 | 1953-09-02 | Georgi | Facello | M | 1986-06-26 | | 10002 | 1964-06-02 | Bezalel | Simmel | F | 1985-11-21 | | 10003 | 1959-12-03 | Parto | Bamford | M | 1986-08-28 | | 10004 | 1954-05-01 | Chirstian | Koblick | M | 1986-12-01 | | 10005 | 1955-01-21 | Kyoichi | Maliniak | M | 1989-09-12 | +--------+------------+------------+-----------+--------+------------+ 5 rows in set (0.00 sec) Select specific fields for all records mysql> select first_name, last_name, gender from employees limit 5; +------------+-----------+--------+ | first_name | last_name | gender | +------------+-----------+--------+ | Georgi | Facello | M | | Bezalel | Simmel | F | | Parto | Bamford | M | | Chirstian | Koblick | M | | Kyoichi | Maliniak | M | +------------+-----------+--------+ 5 rows in set (0.00 sec) Select all records Where hire_date >= January 1, 1990 mysql> select * from employees where hire_date >= '1990-01-01' limit 5; +--------+------------+------------+-------------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-------------+--------+------------+ | 10008 | 1958-02-19 | Saniya | Kalloufi | M | 1994-09-15 | | 10011 | 1953-11-07 | Mary | Sluis | F | 1990-01-22 | | 10012 | 1960-10-04 | Patricio | Bridgland | M | 1992-12-18 | | 10016 | 1961-05-02 | Kazuhito | Cappelletti | M | 1995-01-27 | | 10017 | 1958-07-06 | Cristinel | Bouloucos | F | 1993-08-03 | +--------+------------+------------+-------------+--------+------------+ 5 rows in set (0.01 sec) Select first_name and last_name from all records Where birth_date >= 1960 AND gender = \u2018F\u2019 mysql> select first_name, last_name from employees where year(birth_date) >= 1960 and gender='F' limit 5; +------------+-----------+ | first_name | last_name | +------------+-----------+ | Bezalel | Simmel | | Duangkaew | Piveteau | | Divier | Reistad | | Jeong | Reistad | | Mingsen | Casley | +------------+-----------+ 5 rows in set (0.00 sec) Display the total number of records mysql> select count(*) from employees; +----------+ | count(*) | +----------+ | 300024 | +----------+ 1 row in set (0.05 sec) Display gender-wise count of all records mysql> select gender, count(*) from employees group by gender; +--------+----------+ | gender | count(*) | +--------+----------+ | M | 179973 | | F | 120051 | +--------+----------+ 2 rows in set (0.14 sec) Display the year of hire_date and number of employees hired that year, also only those years where more than 20k employees were hired mysql> select year(hire_date), count(*) from employees group by year(hire_date) having count(*) > 20000; +-----------------+----------+ | year(hire_date) | count(*) | +-----------------+----------+ | 1985 | 35316 | | 1986 | 36150 | | 1987 | 33501 | | 1988 | 31436 | | 1989 | 28394 | | 1990 | 25610 | | 1991 | 22568 | | 1992 | 20402 | +-----------------+----------+ 8 rows in set (0.14 sec) Display all records ordered by their hire_date in descending order. If hire_date is the same then in order of their birth_date ascending order mysql> select * from employees order by hire_date desc, birth_date asc limit 5; +--------+------------+------------+-----------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-----------+--------+------------+ | 463807 | 1964-06-12 | Bikash | Covnot | M | 2000-01-28 | | 428377 | 1957-05-09 | Yucai | Gerlach | M | 2000-01-23 | | 499553 | 1954-05-06 | Hideyuki | Delgrande | F | 2000-01-22 | | 222965 | 1959-08-07 | Volkmar | Perko | F | 2000-01-13 | | 47291 | 1960-09-09 | Ulf | Flexer | M | 2000-01-12 | +--------+------------+------------+-----------+--------+------------+ 5 rows in set (0.12 sec) SELECT - JOINS JOIN statement is used to produce a combined result set from two or more tables based on certain conditions. It can be also used with Update and Delete statements but we will be focussing on the select query. Following is a basic general form for joins SELECT table1.col1, table2.col1, ... (any combination) FROM table1 table2 ON (or USING depends on join_type) table1.column_for_joining = table2.column_for_joining WHERE \u2026 Any number of columns can be selected, but it is recommended to select only those which are relevant to increase the readability of the resultset. All other clauses like where, group by are not mandatory. Let\u2019s discuss the types of JOINs supported by MySQL Syntax. Inner Join This joins table A with table B on a condition. Only the records where the condition is True are selected in the resultset. Display some details of employees along with their salary mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e join salaries s on e.emp_no=s.emp_no limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Similar result can be achieved by mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e join salaries s using (emp_no) limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) And also by mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e natural join salaries s limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Outer Join Majorly of two types:- - LEFT - joining complete table A with table B on a condition. All the records from table A are selected, but from table B, only those records are selected where the condition is True. - RIGHT - Exact opposite of the left join. Let us assume the below tables for understanding left join better. mysql> select * from dummy1; +----------+------------+ | same_col | diff_col_1 | +----------+------------+ | 1 | A | | 2 | B | | 3 | C | +----------+------------+ mysql> select * from dummy2; +----------+------------+ | same_col | diff_col_2 | +----------+------------+ | 1 | X | | 3 | Y | +----------+------------+ A simple select join will look like the one below. mysql> select * from dummy1 d1 left join dummy2 d2 on d1.same_col=d2.same_col; +----------+------------+----------+------------+ | same_col | diff_col_1 | same_col | diff_col_2 | +----------+------------+----------+------------+ | 1 | A | 1 | X | | 3 | C | 3 | Y | | 2 | B | NULL | NULL | +----------+------------+----------+------------+ 3 rows in set (0.00 sec) Which can also be written as mysql> select * from dummy1 d1 left join dummy2 d2 using(same_col); +----------+------------+------------+ | same_col | diff_col_1 | diff_col_2 | +----------+------------+------------+ | 1 | A | X | | 3 | C | Y | | 2 | B | NULL | +----------+------------+------------+ 3 rows in set (0.00 sec) And also as mysql> select * from dummy1 d1 natural left join dummy2 d2; +----------+------------+------------+ | same_col | diff_col_1 | diff_col_2 | +----------+------------+------------+ | 1 | A | X | | 3 | C | Y | | 2 | B | NULL | +----------+------------+------------+ 3 rows in set (0.00 sec) Cross Join This does a cross product of table A and table B without any condition. It doesn\u2019t have a lot of applications in the real world. A Simple Cross Join looks like this mysql> select * from dummy1 cross join dummy2; +----------+------------+----------+------------+ | same_col | diff_col_1 | same_col | diff_col_2 | +----------+------------+----------+------------+ | 1 | A | 3 | Y | | 1 | A | 1 | X | | 2 | B | 3 | Y | | 2 | B | 1 | X | | 3 | C | 3 | Y | | 3 | C | 1 | X | +----------+------------+----------+------------+ 6 rows in set (0.01 sec) One use case that can come in handy is when you have to fill in some missing entries. For example, all the entries from dummy1 must be inserted into a similar table dummy3, with each record must have 3 entries with statuses 1, 5 and 7. mysql> desc dummy3; +----------+----------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +----------+----------+------+-----+---------+-------+ | same_col | int | YES | | NULL | | | value | char(15) | YES | | NULL | | | status | smallint | YES | | NULL | | +----------+----------+------+-----+---------+-------+ 3 rows in set (0.02 sec) Either you create an insert query script with as many entries as in dummy1 or use cross join to produce the required resultset. mysql> select * from dummy1 cross join (select 1 union select 5 union select 7) T2 order by same_col; +----------+------------+---+ | same_col | diff_col_1 | 1 | +----------+------------+---+ | 1 | A | 1 | | 1 | A | 5 | | 1 | A | 7 | | 2 | B | 1 | | 2 | B | 5 | | 2 | B | 7 | | 3 | C | 1 | | 3 | C | 5 | | 3 | C | 7 | +----------+------------+---+ 9 rows in set (0.00 sec) The T2 section in the above query is called a sub-query . We will discuss the same in the next section. Natural Join This implicitly selects the common column from table A and table B and performs an inner join. mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e natural join salaries s limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Notice how natural join and using takes care that the common column is displayed only once if you are not explicitly selecting columns for the query. Some More Examples Display emp_no, salary, title and dept of the employees where salary > 80000 mysql> select e.emp_no, s.salary, t.title, d.dept_no from employees e join salaries s using (emp_no) join titles t using (emp_no) join dept_emp d using (emp_no) where s.salary > 80000 limit 5; +--------+--------+--------------+---------+ | emp_no | salary | title | dept_no | +--------+--------+--------------+---------+ | 10017 | 82163 | Senior Staff | d001 | | 10017 | 86157 | Senior Staff | d001 | | 10017 | 89619 | Senior Staff | d001 | | 10017 | 91985 | Senior Staff | d001 | | 10017 | 96122 | Senior Staff | d001 | +--------+--------+--------------+---------+ 5 rows in set (0.00 sec) Display title-wise count of employees in each department order by dept_no mysql> select d.dept_no, t.title, count(*) from titles t left join dept_emp d using (emp_no) group by d.dept_no, t.title order by d.dept_no limit 10; +---------+--------------------+----------+ | dept_no | title | count(*) | +---------+--------------------+----------+ | d001 | Manager | 2 | | d001 | Senior Staff | 13940 | | d001 | Staff | 16196 | | d002 | Manager | 2 | | d002 | Senior Staff | 12139 | | d002 | Staff | 13929 | | d003 | Manager | 2 | | d003 | Senior Staff | 12274 | | d003 | Staff | 14342 | | d004 | Assistant Engineer | 6445 | +---------+--------------------+----------+ 10 rows in set (1.32 sec) SELECT - Subquery A subquery is generally a smaller resultset that can be used to power a select query in many ways. It can be used in a \u2018where\u2019 condition, can be used in place of join mostly where a join could be an overkill. These subqueries are also termed as derived tables. They must have a table alias in the select query. Let\u2019s look at some examples of subqueries. Here we got the department name from the departments table by a subquery which used dept_no from dept_emp table. mysql> select e.emp_no, (select dept_name from departments where dept_no=d.dept_no) dept_name from employees e join dept_emp d using (emp_no) limit 5; +--------+-----------------+ | emp_no | dept_name | +--------+-----------------+ | 10001 | Development | | 10002 | Sales | | 10003 | Production | | 10004 | Production | | 10005 | Human Resources | +--------+-----------------+ 5 rows in set (0.01 sec) Here, we used the \u2018avg\u2019 query above (which got the avg salary) as a subquery to list the employees whose latest salary is more than the average. mysql> select avg(salary) from salaries; +-------------+ | avg(salary) | +-------------+ | 63810.7448 | +-------------+ 1 row in set (0.80 sec) mysql> select e.emp_no, max(s.salary) from employees e natural join salaries s group by e.emp_no having max(s.salary) > (select avg(salary) from salaries) limit 10; +--------+---------------+ | emp_no | max(s.salary) | +--------+---------------+ | 10001 | 88958 | | 10002 | 72527 | | 10004 | 74057 | | 10005 | 94692 | | 10007 | 88070 | | 10009 | 94443 | | 10010 | 80324 | | 10013 | 68901 | | 10016 | 77935 | | 10017 | 99651 | +--------+---------------+ 10 rows in set (0.56 sec)","title":"Select Query"},{"location":"level101/databases_sql/select_query/#select-query","text":"The most commonly used command while working with MySQL is SELECT. It is used to fetch the result set from one or more tables. The general form of a typical select query looks like:- SELECT expr FROM table1 [WHERE condition] [GROUP BY column_list HAVING condition] [ORDER BY column_list ASC|DESC] [LIMIT #] The above general form contains some commonly used clauses of a SELECT query:- expr - comma-separated column list or * (for all columns) WHERE - a condition is provided, if true, directs the query to select only those records. GROUP BY - groups the entire result set based on the column list provided. An aggregate function is recommended to be present in the select expression of the query. HAVING supports grouping by putting a condition on the selected or any other aggregate function. ORDER BY - sorts the result set based on the column list in ascending or descending order. LIMIT - commonly used to limit the number of records. Let\u2019s have a look at some examples for a better understanding of the above. The dataset used for the examples below is available here and is free to use. Select all records mysql> select * from employees limit 5; +--------+------------+------------+-----------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-----------+--------+------------+ | 10001 | 1953-09-02 | Georgi | Facello | M | 1986-06-26 | | 10002 | 1964-06-02 | Bezalel | Simmel | F | 1985-11-21 | | 10003 | 1959-12-03 | Parto | Bamford | M | 1986-08-28 | | 10004 | 1954-05-01 | Chirstian | Koblick | M | 1986-12-01 | | 10005 | 1955-01-21 | Kyoichi | Maliniak | M | 1989-09-12 | +--------+------------+------------+-----------+--------+------------+ 5 rows in set (0.00 sec) Select specific fields for all records mysql> select first_name, last_name, gender from employees limit 5; +------------+-----------+--------+ | first_name | last_name | gender | +------------+-----------+--------+ | Georgi | Facello | M | | Bezalel | Simmel | F | | Parto | Bamford | M | | Chirstian | Koblick | M | | Kyoichi | Maliniak | M | +------------+-----------+--------+ 5 rows in set (0.00 sec) Select all records Where hire_date >= January 1, 1990 mysql> select * from employees where hire_date >= '1990-01-01' limit 5; +--------+------------+------------+-------------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-------------+--------+------------+ | 10008 | 1958-02-19 | Saniya | Kalloufi | M | 1994-09-15 | | 10011 | 1953-11-07 | Mary | Sluis | F | 1990-01-22 | | 10012 | 1960-10-04 | Patricio | Bridgland | M | 1992-12-18 | | 10016 | 1961-05-02 | Kazuhito | Cappelletti | M | 1995-01-27 | | 10017 | 1958-07-06 | Cristinel | Bouloucos | F | 1993-08-03 | +--------+------------+------------+-------------+--------+------------+ 5 rows in set (0.01 sec) Select first_name and last_name from all records Where birth_date >= 1960 AND gender = \u2018F\u2019 mysql> select first_name, last_name from employees where year(birth_date) >= 1960 and gender='F' limit 5; +------------+-----------+ | first_name | last_name | +------------+-----------+ | Bezalel | Simmel | | Duangkaew | Piveteau | | Divier | Reistad | | Jeong | Reistad | | Mingsen | Casley | +------------+-----------+ 5 rows in set (0.00 sec) Display the total number of records mysql> select count(*) from employees; +----------+ | count(*) | +----------+ | 300024 | +----------+ 1 row in set (0.05 sec) Display gender-wise count of all records mysql> select gender, count(*) from employees group by gender; +--------+----------+ | gender | count(*) | +--------+----------+ | M | 179973 | | F | 120051 | +--------+----------+ 2 rows in set (0.14 sec) Display the year of hire_date and number of employees hired that year, also only those years where more than 20k employees were hired mysql> select year(hire_date), count(*) from employees group by year(hire_date) having count(*) > 20000; +-----------------+----------+ | year(hire_date) | count(*) | +-----------------+----------+ | 1985 | 35316 | | 1986 | 36150 | | 1987 | 33501 | | 1988 | 31436 | | 1989 | 28394 | | 1990 | 25610 | | 1991 | 22568 | | 1992 | 20402 | +-----------------+----------+ 8 rows in set (0.14 sec) Display all records ordered by their hire_date in descending order. If hire_date is the same then in order of their birth_date ascending order mysql> select * from employees order by hire_date desc, birth_date asc limit 5; +--------+------------+------------+-----------+--------+------------+ | emp_no | birth_date | first_name | last_name | gender | hire_date | +--------+------------+------------+-----------+--------+------------+ | 463807 | 1964-06-12 | Bikash | Covnot | M | 2000-01-28 | | 428377 | 1957-05-09 | Yucai | Gerlach | M | 2000-01-23 | | 499553 | 1954-05-06 | Hideyuki | Delgrande | F | 2000-01-22 | | 222965 | 1959-08-07 | Volkmar | Perko | F | 2000-01-13 | | 47291 | 1960-09-09 | Ulf | Flexer | M | 2000-01-12 | +--------+------------+------------+-----------+--------+------------+ 5 rows in set (0.12 sec)","title":"SELECT Query"},{"location":"level101/databases_sql/select_query/#select-joins","text":"JOIN statement is used to produce a combined result set from two or more tables based on certain conditions. It can be also used with Update and Delete statements but we will be focussing on the select query. Following is a basic general form for joins SELECT table1.col1, table2.col1, ... (any combination) FROM table1 table2 ON (or USING depends on join_type) table1.column_for_joining = table2.column_for_joining WHERE \u2026 Any number of columns can be selected, but it is recommended to select only those which are relevant to increase the readability of the resultset. All other clauses like where, group by are not mandatory. Let\u2019s discuss the types of JOINs supported by MySQL Syntax. Inner Join This joins table A with table B on a condition. Only the records where the condition is True are selected in the resultset. Display some details of employees along with their salary mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e join salaries s on e.emp_no=s.emp_no limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Similar result can be achieved by mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e join salaries s using (emp_no) limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) And also by mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e natural join salaries s limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Outer Join Majorly of two types:- - LEFT - joining complete table A with table B on a condition. All the records from table A are selected, but from table B, only those records are selected where the condition is True. - RIGHT - Exact opposite of the left join. Let us assume the below tables for understanding left join better. mysql> select * from dummy1; +----------+------------+ | same_col | diff_col_1 | +----------+------------+ | 1 | A | | 2 | B | | 3 | C | +----------+------------+ mysql> select * from dummy2; +----------+------------+ | same_col | diff_col_2 | +----------+------------+ | 1 | X | | 3 | Y | +----------+------------+ A simple select join will look like the one below. mysql> select * from dummy1 d1 left join dummy2 d2 on d1.same_col=d2.same_col; +----------+------------+----------+------------+ | same_col | diff_col_1 | same_col | diff_col_2 | +----------+------------+----------+------------+ | 1 | A | 1 | X | | 3 | C | 3 | Y | | 2 | B | NULL | NULL | +----------+------------+----------+------------+ 3 rows in set (0.00 sec) Which can also be written as mysql> select * from dummy1 d1 left join dummy2 d2 using(same_col); +----------+------------+------------+ | same_col | diff_col_1 | diff_col_2 | +----------+------------+------------+ | 1 | A | X | | 3 | C | Y | | 2 | B | NULL | +----------+------------+------------+ 3 rows in set (0.00 sec) And also as mysql> select * from dummy1 d1 natural left join dummy2 d2; +----------+------------+------------+ | same_col | diff_col_1 | diff_col_2 | +----------+------------+------------+ | 1 | A | X | | 3 | C | Y | | 2 | B | NULL | +----------+------------+------------+ 3 rows in set (0.00 sec) Cross Join This does a cross product of table A and table B without any condition. It doesn\u2019t have a lot of applications in the real world. A Simple Cross Join looks like this mysql> select * from dummy1 cross join dummy2; +----------+------------+----------+------------+ | same_col | diff_col_1 | same_col | diff_col_2 | +----------+------------+----------+------------+ | 1 | A | 3 | Y | | 1 | A | 1 | X | | 2 | B | 3 | Y | | 2 | B | 1 | X | | 3 | C | 3 | Y | | 3 | C | 1 | X | +----------+------------+----------+------------+ 6 rows in set (0.01 sec) One use case that can come in handy is when you have to fill in some missing entries. For example, all the entries from dummy1 must be inserted into a similar table dummy3, with each record must have 3 entries with statuses 1, 5 and 7. mysql> desc dummy3; +----------+----------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +----------+----------+------+-----+---------+-------+ | same_col | int | YES | | NULL | | | value | char(15) | YES | | NULL | | | status | smallint | YES | | NULL | | +----------+----------+------+-----+---------+-------+ 3 rows in set (0.02 sec) Either you create an insert query script with as many entries as in dummy1 or use cross join to produce the required resultset. mysql> select * from dummy1 cross join (select 1 union select 5 union select 7) T2 order by same_col; +----------+------------+---+ | same_col | diff_col_1 | 1 | +----------+------------+---+ | 1 | A | 1 | | 1 | A | 5 | | 1 | A | 7 | | 2 | B | 1 | | 2 | B | 5 | | 2 | B | 7 | | 3 | C | 1 | | 3 | C | 5 | | 3 | C | 7 | +----------+------------+---+ 9 rows in set (0.00 sec) The T2 section in the above query is called a sub-query . We will discuss the same in the next section. Natural Join This implicitly selects the common column from table A and table B and performs an inner join. mysql> select e.emp_no,e.first_name,e.last_name,s.salary from employees e natural join salaries s limit 5; +--------+------------+-----------+--------+ | emp_no | first_name | last_name | salary | +--------+------------+-----------+--------+ | 10001 | Georgi | Facello | 60117 | | 10001 | Georgi | Facello | 62102 | | 10001 | Georgi | Facello | 66074 | | 10001 | Georgi | Facello | 66596 | | 10001 | Georgi | Facello | 66961 | +--------+------------+-----------+--------+ 5 rows in set (0.00 sec) Notice how natural join and using takes care that the common column is displayed only once if you are not explicitly selecting columns for the query. Some More Examples Display emp_no, salary, title and dept of the employees where salary > 80000 mysql> select e.emp_no, s.salary, t.title, d.dept_no from employees e join salaries s using (emp_no) join titles t using (emp_no) join dept_emp d using (emp_no) where s.salary > 80000 limit 5; +--------+--------+--------------+---------+ | emp_no | salary | title | dept_no | +--------+--------+--------------+---------+ | 10017 | 82163 | Senior Staff | d001 | | 10017 | 86157 | Senior Staff | d001 | | 10017 | 89619 | Senior Staff | d001 | | 10017 | 91985 | Senior Staff | d001 | | 10017 | 96122 | Senior Staff | d001 | +--------+--------+--------------+---------+ 5 rows in set (0.00 sec) Display title-wise count of employees in each department order by dept_no mysql> select d.dept_no, t.title, count(*) from titles t left join dept_emp d using (emp_no) group by d.dept_no, t.title order by d.dept_no limit 10; +---------+--------------------+----------+ | dept_no | title | count(*) | +---------+--------------------+----------+ | d001 | Manager | 2 | | d001 | Senior Staff | 13940 | | d001 | Staff | 16196 | | d002 | Manager | 2 | | d002 | Senior Staff | 12139 | | d002 | Staff | 13929 | | d003 | Manager | 2 | | d003 | Senior Staff | 12274 | | d003 | Staff | 14342 | | d004 | Assistant Engineer | 6445 | +---------+--------------------+----------+ 10 rows in set (1.32 sec)","title":"SELECT - JOINS"},{"location":"level101/databases_sql/select_query/#select-subquery","text":"A subquery is generally a smaller resultset that can be used to power a select query in many ways. It can be used in a \u2018where\u2019 condition, can be used in place of join mostly where a join could be an overkill. These subqueries are also termed as derived tables. They must have a table alias in the select query. Let\u2019s look at some examples of subqueries. Here we got the department name from the departments table by a subquery which used dept_no from dept_emp table. mysql> select e.emp_no, (select dept_name from departments where dept_no=d.dept_no) dept_name from employees e join dept_emp d using (emp_no) limit 5; +--------+-----------------+ | emp_no | dept_name | +--------+-----------------+ | 10001 | Development | | 10002 | Sales | | 10003 | Production | | 10004 | Production | | 10005 | Human Resources | +--------+-----------------+ 5 rows in set (0.01 sec) Here, we used the \u2018avg\u2019 query above (which got the avg salary) as a subquery to list the employees whose latest salary is more than the average. mysql> select avg(salary) from salaries; +-------------+ | avg(salary) | +-------------+ | 63810.7448 | +-------------+ 1 row in set (0.80 sec) mysql> select e.emp_no, max(s.salary) from employees e natural join salaries s group by e.emp_no having max(s.salary) > (select avg(salary) from salaries) limit 10; +--------+---------------+ | emp_no | max(s.salary) | +--------+---------------+ | 10001 | 88958 | | 10002 | 72527 | | 10004 | 74057 | | 10005 | 94692 | | 10007 | 88070 | | 10009 | 94443 | | 10010 | 80324 | | 10013 | 68901 | | 10016 | 77935 | | 10017 | 99651 | +--------+---------------+ 10 rows in set (0.56 sec)","title":"SELECT - Subquery"},{"location":"level101/git/branches/","text":"Working With Branches Coming back to our local repo which has two commits. So far, what we have is a single line of history. Commits are chained in a single line. But sometimes you may have a need to work on two different features in parallel in the same repo. Now one option here could be making a new folder/repo with the same code and use that for another feature development. But there's a better way. Use branches. Since git follows tree like structure for commits, we can use branches to work on different sets of features. From a commit, two or more branches can be created and branches can also be merged. Using branches, there can exist multiple lines of histories and we can checkout to any of them and work on it. Checking out, as we discussed earlier, would simply mean replacing contents of the directory (repo) with the snapshot at the checked out version. Let's create a branch and see how it looks like: $ git branch b1 $ git log --oneline --graph * 7f3b00e (HEAD -> master, b1) adding file 2 * df2fb7a adding file 1 We create a branch called b1 . Git log tells us that b1 also points to the last commit (7f3b00e) but the HEAD is still pointing to master. If you remember, HEAD points to the commit/reference wherever you are checkout to. So if we checkout to b1 , HEAD should point to that. Let's confirm: $ git checkout b1 Switched to branch 'b1' $ git log --oneline --graph * 7f3b00e (HEAD -> b1, master) adding file 2 * df2fb7a adding file 1 b1 still points to the same commit but HEAD now points to b1 . Since we create a branch at commit 7f3b00e , there will be two lines of histories starting this commit. Depending on which branch you are checked out on, the line of history will progress. At this moment, we are checked out on branch b1 , so making a new commit will advance branch reference b1 to that commit and current b1 commit will become its parent. Let's do that. # Creating a file and making a commit $ echo \"I am a file in b1 branch\" > b1.txt $ git add b1.txt $ git commit -m \"adding b1 file\" [b1 872a38f] adding b1 file 1 file changed, 1 insertion(+) create mode 100644 b1.txt # The new line of history $ git log --oneline --graph * 872a38f (HEAD -> b1) adding b1 file * 7f3b00e (master) adding file 2 * df2fb7a adding file 1 $ Do note that master is still pointing to the old commit it was pointing to. We can now checkout to master branch and make commits there. This will result in another line of history starting from commit 7f3b00e. # checkout to master branch $ git checkout master Switched to branch 'master' # Creating a new commit on master branch $ echo \"new file in master branch\" > master.txt $ git add master.txt $ git commit -m \"adding master.txt file\" [master 60dc441] adding master.txt file 1 file changed, 1 insertion(+) create mode 100644 master.txt # The history line $ git log --oneline --graph * 60dc441 (HEAD -> master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 Notice how branch b1 is not visible here since we are on the master. Let's try to visualize both to get the whole picture: $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Above tree structure should make things clear. Notice a clear branch/fork on commit 7f3b00e. This is how we create branches. Now they both are two separate lines of history on which feature development can be done independently. To reiterate, internally, git is just a tree of commits. Branch names (human readable) are pointers to those commits in the tree. We use various git commands to work with the tree structure and references. Git accordingly modifies contents of our repo. Merges Now say the feature you were working on branch b1 is complete and you need to merge it on master branch, where all the final version of code goes. So first you will checkout to branch master and then you pull the latest code from upstream (eg: GitHub). Then you need to merge your code from b1 into master. There could be two ways this can be done. Here is the current history: $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Option 1: Directly merge the branch. Merging the branch b1 into master will result in a new merge commit. This will merge changes from two different lines of history and create a new commit of the result. $ git merge b1 Merge made by the 'recursive' strategy. b1.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 b1.txt $ git log --oneline --graph --all * 8fc28f9 (HEAD -> master) Merge branch 'b1' |\\ | * 872a38f (b1) adding b1 file * | 60dc441 adding master.txt file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 You can see a new merge commit created (8fc28f9). You will be prompted for the commit message. If there are a lot of branches in the repo, this result will end-up with a lot of merge commits. Which looks ugly compared to a single line of history of development. So let's look at an alternative approach First let's reset our last merge and go to the previous state. $ git reset --hard 60dc441 HEAD is now at 60dc441 adding master.txt file $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Option 2: Rebase. Now, instead of merging two branches which has a similar base (commit: 7f3b00e), let us rebase branch b1 on to current master. What this means is take branch b1 (from commit 7f3b00e to commit 872a38f) and rebase (put them on top of) master (60dc441). # Switch to b1 $ git checkout b1 Switched to branch 'b1' # Rebase (b1 which is current branch) on master $ git rebase master First, rewinding head to replay your work on top of it... Applying: adding b1 file # The result $ git log --oneline --graph --all * 5372c8f (HEAD -> b1) adding b1 file * 60dc441 (master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 You can see b1 which had 1 commit. That commit's parent was 7f3b00e . But since we rebase it on master ( 60dc441 ). That becomes the parent now. As a side effect, you also see it has become a single line of history. Now if we were to merge b1 into master , it would simply mean change master to point to 5372c8f which is b1 . Let's try it: # checkout to master since we want to merge code into master $ git checkout master Switched to branch 'master' # the current history, where b1 is based on master $ git log --oneline --graph --all * 5372c8f (b1) adding b1 file * 60dc441 (HEAD -> master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 # Performing the merge, notice the \"fast-forward\" message $ git merge b1 Updating 60dc441..5372c8f Fast-forward b1.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 b1.txt # The Result $ git log --oneline --graph --all * 5372c8f (HEAD -> master, b1) adding b1 file * 60dc441 adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 Now you see both b1 and master are pointing to the same commit. Your code has been merged to the master branch and it can be pushed. Also we have clean line of history! :D","title":"Working With Branches"},{"location":"level101/git/branches/#working-with-branches","text":"Coming back to our local repo which has two commits. So far, what we have is a single line of history. Commits are chained in a single line. But sometimes you may have a need to work on two different features in parallel in the same repo. Now one option here could be making a new folder/repo with the same code and use that for another feature development. But there's a better way. Use branches. Since git follows tree like structure for commits, we can use branches to work on different sets of features. From a commit, two or more branches can be created and branches can also be merged. Using branches, there can exist multiple lines of histories and we can checkout to any of them and work on it. Checking out, as we discussed earlier, would simply mean replacing contents of the directory (repo) with the snapshot at the checked out version. Let's create a branch and see how it looks like: $ git branch b1 $ git log --oneline --graph * 7f3b00e (HEAD -> master, b1) adding file 2 * df2fb7a adding file 1 We create a branch called b1 . Git log tells us that b1 also points to the last commit (7f3b00e) but the HEAD is still pointing to master. If you remember, HEAD points to the commit/reference wherever you are checkout to. So if we checkout to b1 , HEAD should point to that. Let's confirm: $ git checkout b1 Switched to branch 'b1' $ git log --oneline --graph * 7f3b00e (HEAD -> b1, master) adding file 2 * df2fb7a adding file 1 b1 still points to the same commit but HEAD now points to b1 . Since we create a branch at commit 7f3b00e , there will be two lines of histories starting this commit. Depending on which branch you are checked out on, the line of history will progress. At this moment, we are checked out on branch b1 , so making a new commit will advance branch reference b1 to that commit and current b1 commit will become its parent. Let's do that. # Creating a file and making a commit $ echo \"I am a file in b1 branch\" > b1.txt $ git add b1.txt $ git commit -m \"adding b1 file\" [b1 872a38f] adding b1 file 1 file changed, 1 insertion(+) create mode 100644 b1.txt # The new line of history $ git log --oneline --graph * 872a38f (HEAD -> b1) adding b1 file * 7f3b00e (master) adding file 2 * df2fb7a adding file 1 $ Do note that master is still pointing to the old commit it was pointing to. We can now checkout to master branch and make commits there. This will result in another line of history starting from commit 7f3b00e. # checkout to master branch $ git checkout master Switched to branch 'master' # Creating a new commit on master branch $ echo \"new file in master branch\" > master.txt $ git add master.txt $ git commit -m \"adding master.txt file\" [master 60dc441] adding master.txt file 1 file changed, 1 insertion(+) create mode 100644 master.txt # The history line $ git log --oneline --graph * 60dc441 (HEAD -> master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 Notice how branch b1 is not visible here since we are on the master. Let's try to visualize both to get the whole picture: $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Above tree structure should make things clear. Notice a clear branch/fork on commit 7f3b00e. This is how we create branches. Now they both are two separate lines of history on which feature development can be done independently. To reiterate, internally, git is just a tree of commits. Branch names (human readable) are pointers to those commits in the tree. We use various git commands to work with the tree structure and references. Git accordingly modifies contents of our repo.","title":"Working With Branches"},{"location":"level101/git/branches/#merges","text":"Now say the feature you were working on branch b1 is complete and you need to merge it on master branch, where all the final version of code goes. So first you will checkout to branch master and then you pull the latest code from upstream (eg: GitHub). Then you need to merge your code from b1 into master. There could be two ways this can be done. Here is the current history: $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Option 1: Directly merge the branch. Merging the branch b1 into master will result in a new merge commit. This will merge changes from two different lines of history and create a new commit of the result. $ git merge b1 Merge made by the 'recursive' strategy. b1.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 b1.txt $ git log --oneline --graph --all * 8fc28f9 (HEAD -> master) Merge branch 'b1' |\\ | * 872a38f (b1) adding b1 file * | 60dc441 adding master.txt file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 You can see a new merge commit created (8fc28f9). You will be prompted for the commit message. If there are a lot of branches in the repo, this result will end-up with a lot of merge commits. Which looks ugly compared to a single line of history of development. So let's look at an alternative approach First let's reset our last merge and go to the previous state. $ git reset --hard 60dc441 HEAD is now at 60dc441 adding master.txt file $ git log --oneline --graph --all * 60dc441 (HEAD -> master) adding master.txt file | * 872a38f (b1) adding b1 file |/ * 7f3b00e adding file 2 * df2fb7a adding file 1 Option 2: Rebase. Now, instead of merging two branches which has a similar base (commit: 7f3b00e), let us rebase branch b1 on to current master. What this means is take branch b1 (from commit 7f3b00e to commit 872a38f) and rebase (put them on top of) master (60dc441). # Switch to b1 $ git checkout b1 Switched to branch 'b1' # Rebase (b1 which is current branch) on master $ git rebase master First, rewinding head to replay your work on top of it... Applying: adding b1 file # The result $ git log --oneline --graph --all * 5372c8f (HEAD -> b1) adding b1 file * 60dc441 (master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 You can see b1 which had 1 commit. That commit's parent was 7f3b00e . But since we rebase it on master ( 60dc441 ). That becomes the parent now. As a side effect, you also see it has become a single line of history. Now if we were to merge b1 into master , it would simply mean change master to point to 5372c8f which is b1 . Let's try it: # checkout to master since we want to merge code into master $ git checkout master Switched to branch 'master' # the current history, where b1 is based on master $ git log --oneline --graph --all * 5372c8f (b1) adding b1 file * 60dc441 (HEAD -> master) adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 # Performing the merge, notice the \"fast-forward\" message $ git merge b1 Updating 60dc441..5372c8f Fast-forward b1.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 b1.txt # The Result $ git log --oneline --graph --all * 5372c8f (HEAD -> master, b1) adding b1 file * 60dc441 adding master.txt file * 7f3b00e adding file 2 * df2fb7a adding file 1 Now you see both b1 and master are pointing to the same commit. Your code has been merged to the master branch and it can be pushed. Also we have clean line of history! :D","title":"Merges"},{"location":"level101/git/conclusion/","text":"What next from here? There are a lot of git commands and features which we have not explored here. But with the base built-up, be sure to explore concepts like Cherrypick Squash Amend Stash Reset","title":"Conclusion"},{"location":"level101/git/conclusion/#what-next-from-here","text":"There are a lot of git commands and features which we have not explored here. But with the base built-up, be sure to explore concepts like Cherrypick Squash Amend Stash Reset","title":"What next from here?"},{"location":"level101/git/git-basics/","text":"Git Prerequisites Have Git installed https://git-scm.com/downloads Have taken any git high level tutorial or following LinkedIn learning courses https://www.linkedin.com/learning/git-essential-training-the-basics/ https://www.linkedin.com/learning/git-branches-merges-and-remotes/ The Official Git Docs What to expect from this course As an engineer in the field of computer science, having knowledge of version control tools becomes almost a requirement. While there are a lot of version control tools that exist today like SVN, Mercurial, etc, Git perhaps is the most used one and this course we will be working with Git. While this course does not start with Git 101 and expects basic knowledge of git as a prerequisite, it will reintroduce the git concepts known by you with details covering what is happening under the hood as you execute various git commands. So that next time you run a git command, you will be able to press enter more confidently! What is not covered under this course Advanced usage and specifics of internal implementation details of Git. Course Contents Git Basics Working with Branches Git with Github Hooks Git Basics Though you might be aware already, let's revisit why we need a version control system. As the project grows and multiple developers start working on it, an efficient method for collaboration is warranted. Git helps the team collaborate easily and also maintains the history of the changes happening with the codebase. Creating a Git Repo Any folder can be converted into a git repository. After executing the following command, we will see a .git folder within the folder, which makes our folder a git repository. All the magic that git does, .git folder is the enabler for the same. # creating an empty folder and changing current dir to it $ cd /tmp $ mkdir school-of-sre $ cd school-of-sre/ # initialize a git repo $ git init Initialized empty Git repository in /private/tmp/school-of-sre/.git/ As the output says, an empty git repo has been initialized in our folder. Let's take a look at what is there. $ ls .git/ HEAD config description hooks info objects refs There are a bunch of folders and files in the .git folder. As I said, all these enables git to do its magic. We will look into some of these folders and files. But for now, what we have is an empty git repository. Tracking a File Now as you might already know, let us create a new file in our repo (we will refer to the folder as repo now.) And see git status $ echo \"I am file 1\" > file1.txt $ git status On branch master No commits yet Untracked files: (use \"git add ...\" to include in what will be committed) file1.txt nothing added to commit but untracked files present (use \"git add\" to track) The current git status says No commits yet and there is one untracked file. Since we just created the file, git is not tracking that file. We explicitly need to ask git to track files and folders. (also checkout gitignore ) And how we do that is via git add command as suggested in the above output. Then we go ahead and create a commit. $ git add file1.txt $ git status On branch master No commits yet Changes to be committed: (use \"git rm --cached ...\" to unstage) new file: file1.txt $ git commit -m \"adding file 1\" [master (root-commit) df2fb7a] adding file 1 1 file changed, 1 insertion(+) create mode 100644 file1.txt Notice how after adding the file, git status says Changes to be committed: . What it means is whatever is listed there, will be included in the next commit. Then we go ahead and create a commit, with an attached messaged via -m . More About a Commit Commit is a snapshot of the repo. Whenever a commit is made, a snapshot of the current state of repo (the folder) is taken and saved. Each commit has a unique ID. ( df2fb7a for the commit we made in the previous step). As we keep adding/changing more and more contents and keep making commits, all those snapshots are stored by git. Again, all this magic happens inside the .git folder. This is where all this snapshot or versions are stored in an efficient manner. Adding More Changes Let us create one more file and commit the change. It would look the same as the previous commit we made. $ echo \"I am file 2\" > file2.txt $ git add file2.txt $ git commit -m \"adding file 2\" [master 7f3b00e] adding file 2 1 file changed, 1 insertion(+) create mode 100644 file2.txt A new commit with ID 7f3b00e has been created. You can issue git status at any time to see the state of the repository. **IMPORTANT: Note that commit IDs are long string (SHA) but we can refer to a commit by its initial few (8 or more) characters too. We will interchangeably using shorter and longer commit IDs.** Now that we have two commits, let's visualize them: $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 git log , as the name suggests, prints the log of all the git commits. Here you see two additional arguments, --oneline prints the shorter version of the log, ie: the commit message only and not the person who made the commit and when. --graph prints it in graph format. Now at this moment the commits might look like just one in each line but all commits are stored as a tree like data structure internally by git. That means there can be two or more children commits of a given commit. And not just a single line of commits. We will look more into this part when we get to the Branches section. For now this is our commit history: df2fb7a ===> 7f3b00e Are commits really linked? As I just said, the two commits we just made are linked via tree like data structure and we saw how they are linked. But let's actually verify it. Everything in git is an object. Newly created files are stored as an object. Changes to file are stored as an objects and even commits are objects. To view contents of an object we can use the following command with the object's ID. We will take a look at the contents of the second commit $ git cat-file -p 7f3b00e tree ebf3af44d253e5328340026e45a9fa9ae3ea1982 parent df2fb7a61f5d40c1191e0fdeb0fc5d6e7969685a author Sanket Patel 1603273316 -0700 committer Sanket Patel 1603273316 -0700 adding file 2 Take a note of parent attribute in the above output. It points to the commit id of the first commit we made. So this proves that they are linked! Additionally you can see the second commit's message in this object. As I said all this magic is enabled by .git folder and the object to which we are looking at also is in that folder. $ ls .git/objects/7f/3b00eaa957815884198e2fdfec29361108d6a9 .git/objects/7f/3b00eaa957815884198e2fdfec29361108d6a9 It is stored in .git/objects/ folder. All the files and changes to them as well are stored in this folder. The Version Control part of Git We already can see two commits (versions) in our git log. One thing a version control tool gives you is ability to browse back and forth in history. For example: some of your users are running an old version of code and they are reporting an issue. In order to debug the issue, you need access to the old code. The one in your current repo is the latest code. In this example, you are working on the second commit (7f3b00e) and someone reported an issue with the code snapshot at commit (df2fb7a). This is how you would get access to the code at any older commit # Current contents, two files present $ ls file1.txt file2.txt # checking out to (an older) commit $ git checkout df2fb7a Note: checking out 'df2fb7a'. You are in 'detached HEAD' state. You can look around, make experimental changes and commit them, and you can discard any commits you make in this state without impacting any branches by performing another checkout. If you want to create a new branch to retain commits you create, you may do so (now or later) by using -b with the checkout command again. Example: git checkout -b HEAD is now at df2fb7a adding file 1 # checking contents, can verify it has old contents $ ls file1.txt So this is how we would get access to old versions/snapshots. All we need is a reference to that snapshot. Upon executing git checkout ... , what git does for you is use the .git folder, see what was the state of things (files and folders) at that version/reference and replace the contents of current directory with those contents. The then-existing content will no longer be present in the local dir (repo) but we can and will still get access to them because they are tracked via git commit and .git folder has them stored/tracked. Reference I mention in the previous section that we need a reference to the version. By default, git repo is made of tree of commits. And each commit has a unique IDs. But the unique ID is not the only thing we can reference commits via. There are multiple ways to reference commits. For example: HEAD is a reference to current commit. Whatever commit your repo is checked out at, HEAD will point to that. HEAD~1 is reference to previous commit. So while checking out previous version in section above, we could have done git checkout HEAD~1 . Similarly, master is also a reference (to a branch). Since git uses tree like structure to store commits, there of course will be branches. And the default branch is called master . Master (or any branch reference) will point to the latest commit in the branch. Even though we have checked out to the previous commit in out repo, master still points to the latest commit. And we can get back to the latest version by checkout at master reference $ git checkout master Previous HEAD position was df2fb7a adding file 1 Switched to branch 'master' # now we will see latest code, with two files $ ls file1.txt file2.txt Note, instead of master in above command, we could have used commit's ID as well. References and The Magic Let's look at the state of things. Two commits, master and HEAD references are pointing to the latest commit $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 The magic? Let's examine these files: $ cat .git/refs/heads/master 7f3b00eaa957815884198e2fdfec29361108d6a9 Viola! Where master is pointing to is stored in a file. Whenever git needs to know where master reference is pointing to, or if git needs to update where master points, it just needs to update the file above. So when you create a new commit, a new commit is created on top of the current commit and the master file is updated with the new commit's ID. Similary, for HEAD reference: $ cat .git/HEAD ref: refs/heads/master We can see HEAD is pointing to a reference called refs/heads/master . So HEAD will point where ever the master points. Little Adventure We discussed how git will update the files as we execute commands. But let's try to do it ourselves, by hand, and see what happens. $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 Now let's change master to point to the previous/first commit. $ echo df2fb7a61f5d40c1191e0fdeb0fc5d6e7969685a > .git/refs/heads/master $ git log --oneline --graph * df2fb7a (HEAD -> master) adding file 1 # RESETTING TO ORIGINAL $ echo 7f3b00eaa957815884198e2fdfec29361108d6a9 > .git/refs/heads/master $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 We just edited the master reference file and now we can see only the first commit in git log. Undoing the change to the file brings the state back to original. Not so much of magic, is it?","title":"Git Basics"},{"location":"level101/git/git-basics/#git","text":"","title":"Git"},{"location":"level101/git/git-basics/#prerequisites","text":"Have Git installed https://git-scm.com/downloads Have taken any git high level tutorial or following LinkedIn learning courses https://www.linkedin.com/learning/git-essential-training-the-basics/ https://www.linkedin.com/learning/git-branches-merges-and-remotes/ The Official Git Docs","title":"Prerequisites"},{"location":"level101/git/git-basics/#what-to-expect-from-this-course","text":"As an engineer in the field of computer science, having knowledge of version control tools becomes almost a requirement. While there are a lot of version control tools that exist today like SVN, Mercurial, etc, Git perhaps is the most used one and this course we will be working with Git. While this course does not start with Git 101 and expects basic knowledge of git as a prerequisite, it will reintroduce the git concepts known by you with details covering what is happening under the hood as you execute various git commands. So that next time you run a git command, you will be able to press enter more confidently!","title":"What to expect from this course"},{"location":"level101/git/git-basics/#what-is-not-covered-under-this-course","text":"Advanced usage and specifics of internal implementation details of Git.","title":"What is not covered under this course"},{"location":"level101/git/git-basics/#course-contents","text":"Git Basics Working with Branches Git with Github Hooks","title":"Course Contents"},{"location":"level101/git/git-basics/#git-basics","text":"Though you might be aware already, let's revisit why we need a version control system. As the project grows and multiple developers start working on it, an efficient method for collaboration is warranted. Git helps the team collaborate easily and also maintains the history of the changes happening with the codebase.","title":"Git Basics"},{"location":"level101/git/git-basics/#creating-a-git-repo","text":"Any folder can be converted into a git repository. After executing the following command, we will see a .git folder within the folder, which makes our folder a git repository. All the magic that git does, .git folder is the enabler for the same. # creating an empty folder and changing current dir to it $ cd /tmp $ mkdir school-of-sre $ cd school-of-sre/ # initialize a git repo $ git init Initialized empty Git repository in /private/tmp/school-of-sre/.git/ As the output says, an empty git repo has been initialized in our folder. Let's take a look at what is there. $ ls .git/ HEAD config description hooks info objects refs There are a bunch of folders and files in the .git folder. As I said, all these enables git to do its magic. We will look into some of these folders and files. But for now, what we have is an empty git repository.","title":"Creating a Git Repo"},{"location":"level101/git/git-basics/#tracking-a-file","text":"Now as you might already know, let us create a new file in our repo (we will refer to the folder as repo now.) And see git status $ echo \"I am file 1\" > file1.txt $ git status On branch master No commits yet Untracked files: (use \"git add ...\" to include in what will be committed) file1.txt nothing added to commit but untracked files present (use \"git add\" to track) The current git status says No commits yet and there is one untracked file. Since we just created the file, git is not tracking that file. We explicitly need to ask git to track files and folders. (also checkout gitignore ) And how we do that is via git add command as suggested in the above output. Then we go ahead and create a commit. $ git add file1.txt $ git status On branch master No commits yet Changes to be committed: (use \"git rm --cached ...\" to unstage) new file: file1.txt $ git commit -m \"adding file 1\" [master (root-commit) df2fb7a] adding file 1 1 file changed, 1 insertion(+) create mode 100644 file1.txt Notice how after adding the file, git status says Changes to be committed: . What it means is whatever is listed there, will be included in the next commit. Then we go ahead and create a commit, with an attached messaged via -m .","title":"Tracking a File"},{"location":"level101/git/git-basics/#more-about-a-commit","text":"Commit is a snapshot of the repo. Whenever a commit is made, a snapshot of the current state of repo (the folder) is taken and saved. Each commit has a unique ID. ( df2fb7a for the commit we made in the previous step). As we keep adding/changing more and more contents and keep making commits, all those snapshots are stored by git. Again, all this magic happens inside the .git folder. This is where all this snapshot or versions are stored in an efficient manner.","title":"More About a Commit"},{"location":"level101/git/git-basics/#adding-more-changes","text":"Let us create one more file and commit the change. It would look the same as the previous commit we made. $ echo \"I am file 2\" > file2.txt $ git add file2.txt $ git commit -m \"adding file 2\" [master 7f3b00e] adding file 2 1 file changed, 1 insertion(+) create mode 100644 file2.txt A new commit with ID 7f3b00e has been created. You can issue git status at any time to see the state of the repository. **IMPORTANT: Note that commit IDs are long string (SHA) but we can refer to a commit by its initial few (8 or more) characters too. We will interchangeably using shorter and longer commit IDs.** Now that we have two commits, let's visualize them: $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 git log , as the name suggests, prints the log of all the git commits. Here you see two additional arguments, --oneline prints the shorter version of the log, ie: the commit message only and not the person who made the commit and when. --graph prints it in graph format. Now at this moment the commits might look like just one in each line but all commits are stored as a tree like data structure internally by git. That means there can be two or more children commits of a given commit. And not just a single line of commits. We will look more into this part when we get to the Branches section. For now this is our commit history: df2fb7a ===> 7f3b00e","title":"Adding More Changes"},{"location":"level101/git/git-basics/#are-commits-really-linked","text":"As I just said, the two commits we just made are linked via tree like data structure and we saw how they are linked. But let's actually verify it. Everything in git is an object. Newly created files are stored as an object. Changes to file are stored as an objects and even commits are objects. To view contents of an object we can use the following command with the object's ID. We will take a look at the contents of the second commit $ git cat-file -p 7f3b00e tree ebf3af44d253e5328340026e45a9fa9ae3ea1982 parent df2fb7a61f5d40c1191e0fdeb0fc5d6e7969685a author Sanket Patel 1603273316 -0700 committer Sanket Patel 1603273316 -0700 adding file 2 Take a note of parent attribute in the above output. It points to the commit id of the first commit we made. So this proves that they are linked! Additionally you can see the second commit's message in this object. As I said all this magic is enabled by .git folder and the object to which we are looking at also is in that folder. $ ls .git/objects/7f/3b00eaa957815884198e2fdfec29361108d6a9 .git/objects/7f/3b00eaa957815884198e2fdfec29361108d6a9 It is stored in .git/objects/ folder. All the files and changes to them as well are stored in this folder.","title":"Are commits really linked?"},{"location":"level101/git/git-basics/#the-version-control-part-of-git","text":"We already can see two commits (versions) in our git log. One thing a version control tool gives you is ability to browse back and forth in history. For example: some of your users are running an old version of code and they are reporting an issue. In order to debug the issue, you need access to the old code. The one in your current repo is the latest code. In this example, you are working on the second commit (7f3b00e) and someone reported an issue with the code snapshot at commit (df2fb7a). This is how you would get access to the code at any older commit # Current contents, two files present $ ls file1.txt file2.txt # checking out to (an older) commit $ git checkout df2fb7a Note: checking out 'df2fb7a'. You are in 'detached HEAD' state. You can look around, make experimental changes and commit them, and you can discard any commits you make in this state without impacting any branches by performing another checkout. If you want to create a new branch to retain commits you create, you may do so (now or later) by using -b with the checkout command again. Example: git checkout -b HEAD is now at df2fb7a adding file 1 # checking contents, can verify it has old contents $ ls file1.txt So this is how we would get access to old versions/snapshots. All we need is a reference to that snapshot. Upon executing git checkout ... , what git does for you is use the .git folder, see what was the state of things (files and folders) at that version/reference and replace the contents of current directory with those contents. The then-existing content will no longer be present in the local dir (repo) but we can and will still get access to them because they are tracked via git commit and .git folder has them stored/tracked.","title":"The Version Control part of Git"},{"location":"level101/git/git-basics/#reference","text":"I mention in the previous section that we need a reference to the version. By default, git repo is made of tree of commits. And each commit has a unique IDs. But the unique ID is not the only thing we can reference commits via. There are multiple ways to reference commits. For example: HEAD is a reference to current commit. Whatever commit your repo is checked out at, HEAD will point to that. HEAD~1 is reference to previous commit. So while checking out previous version in section above, we could have done git checkout HEAD~1 . Similarly, master is also a reference (to a branch). Since git uses tree like structure to store commits, there of course will be branches. And the default branch is called master . Master (or any branch reference) will point to the latest commit in the branch. Even though we have checked out to the previous commit in out repo, master still points to the latest commit. And we can get back to the latest version by checkout at master reference $ git checkout master Previous HEAD position was df2fb7a adding file 1 Switched to branch 'master' # now we will see latest code, with two files $ ls file1.txt file2.txt Note, instead of master in above command, we could have used commit's ID as well.","title":"Reference"},{"location":"level101/git/git-basics/#references-and-the-magic","text":"Let's look at the state of things. Two commits, master and HEAD references are pointing to the latest commit $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 The magic? Let's examine these files: $ cat .git/refs/heads/master 7f3b00eaa957815884198e2fdfec29361108d6a9 Viola! Where master is pointing to is stored in a file. Whenever git needs to know where master reference is pointing to, or if git needs to update where master points, it just needs to update the file above. So when you create a new commit, a new commit is created on top of the current commit and the master file is updated with the new commit's ID. Similary, for HEAD reference: $ cat .git/HEAD ref: refs/heads/master We can see HEAD is pointing to a reference called refs/heads/master . So HEAD will point where ever the master points.","title":"References and The Magic"},{"location":"level101/git/git-basics/#little-adventure","text":"We discussed how git will update the files as we execute commands. But let's try to do it ourselves, by hand, and see what happens. $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 Now let's change master to point to the previous/first commit. $ echo df2fb7a61f5d40c1191e0fdeb0fc5d6e7969685a > .git/refs/heads/master $ git log --oneline --graph * df2fb7a (HEAD -> master) adding file 1 # RESETTING TO ORIGINAL $ echo 7f3b00eaa957815884198e2fdfec29361108d6a9 > .git/refs/heads/master $ git log --oneline --graph * 7f3b00e (HEAD -> master) adding file 2 * df2fb7a adding file 1 We just edited the master reference file and now we can see only the first commit in git log. Undoing the change to the file brings the state back to original. Not so much of magic, is it?","title":"Little Adventure"},{"location":"level101/git/github-hooks/","text":"Git with Github Till now all the operations we did were in our local repo while git also helps us in a collaborative environment. GitHub is one place on the internet where you can centrally host your git repos and collaborate with other developers. Most of the workflow will remain the same as we discussed, with addition of couple of things: Pull: to pull latest changes from github (the central) repo Push: to push your changes to github repo so that it's available to all people GitHub has written nice guides and tutorials about this and you can refer them here: GitHub Hello World Git Handbook Hooks Git has another nice feature called hooks. Hooks are basically scripts which will be called when a certain event happens. Here is where hooks are located: $ ls .git/hooks/ applypatch-msg.sample fsmonitor-watchman.sample pre-applypatch.sample pre-push.sample pre-receive.sample update.sample commit-msg.sample post-update.sample pre-commit.sample pre-rebase.sample prepare-commit-msg.sample Names are self explanatory. These hooks are useful when you want to do certain things when a certain event happens. If you want to run tests before pushing code, you would want to setup pre-push hooks. Let's try to create a pre commit hook. $ echo \"echo this is from pre commit hook\" > .git/hooks/pre-commit $ chmod +x .git/hooks/pre-commit We basically create a file called pre-commit in hooks folder and make it executable. Now if we make a commit, we should see the message getting printed. $ echo \"sample file\" > sample.txt $ git add sample.txt $ git commit -m \"adding sample file\" this is from pre commit hook # <===== THE MESSAGE FROM HOOK EXECUTION [master 9894e05] adding sample file 1 file changed, 1 insertion(+) create mode 100644 sample.txt","title":"Github and Hooks"},{"location":"level101/git/github-hooks/#git-with-github","text":"Till now all the operations we did were in our local repo while git also helps us in a collaborative environment. GitHub is one place on the internet where you can centrally host your git repos and collaborate with other developers. Most of the workflow will remain the same as we discussed, with addition of couple of things: Pull: to pull latest changes from github (the central) repo Push: to push your changes to github repo so that it's available to all people GitHub has written nice guides and tutorials about this and you can refer them here: GitHub Hello World Git Handbook","title":"Git with Github"},{"location":"level101/git/github-hooks/#hooks","text":"Git has another nice feature called hooks. Hooks are basically scripts which will be called when a certain event happens. Here is where hooks are located: $ ls .git/hooks/ applypatch-msg.sample fsmonitor-watchman.sample pre-applypatch.sample pre-push.sample pre-receive.sample update.sample commit-msg.sample post-update.sample pre-commit.sample pre-rebase.sample prepare-commit-msg.sample Names are self explanatory. These hooks are useful when you want to do certain things when a certain event happens. If you want to run tests before pushing code, you would want to setup pre-push hooks. Let's try to create a pre commit hook. $ echo \"echo this is from pre commit hook\" > .git/hooks/pre-commit $ chmod +x .git/hooks/pre-commit We basically create a file called pre-commit in hooks folder and make it executable. Now if we make a commit, we should see the message getting printed. $ echo \"sample file\" > sample.txt $ git add sample.txt $ git commit -m \"adding sample file\" this is from pre commit hook # <===== THE MESSAGE FROM HOOK EXECUTION [master 9894e05] adding sample file 1 file changed, 1 insertion(+) create mode 100644 sample.txt","title":"Hooks"},{"location":"level101/linux_basics/command_line_basics/","text":"Command Line Basics Lab Environment Setup One can use an online bash interpreter to run all the commands that are provided as examples in this course. This will also help you in getting a hands-on experience of various linux commands. REPL is one of the popular online bash interpreters for running linux commands. We will be using it for running all the commands mentioned in this course. What is a Command A command is a program that tells the operating system to perform specific work. Programs are stored as files in linux. Therefore, a command is also a file which is stored somewhere on the disk. Commands may also take additional arguments as input from the user. These arguments are called command line arguments. Knowing how to use the commands is important and there are many ways to get help in Linux, especially for commands. Almost every command will have some form of documentation, most commands will have a command-line argument -h or --help that will display a reasonable amount of documentation. But the most popular documentation system in Linux is called man pages - short for manual pages. Using --help to show the documentation for ls command. File System Organization The linux file system has a hierarchical (or tree-like) structure with its highest level directory called root ( denoted by / ). Directories present inside the root directory stores file related to the system. These directories in turn can either store system files or application files or user related files. bin | The executable program of most commonly used commands reside in bin directory sbin | This directory contains programs used for system administration. home | This directory contains user related files and directories. lib | This directory contains all the library files etc | This directory contains all the system configuration files proc | This directory contains files related to the running processes on the system dev | This directory contains files related to devices on the system mnt | This directory contains files related to mounted devices on the system tmp | This directory is used to store temporary files on the system usr | This directory is used to store application programs on the system Commands for Navigating the File System There are three basic commands which are used frequently to navigate the file system: ls pwd cd We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. pwd (print working directory) At any given moment of time, we will be standing in a certain directory. To get the name of the directory in which we are standing, we can use the pwd command in linux. We will now use the cd command to move to a different directory and then print the working directory. cd (change directory) The cd command can be used to change the working directory. Using the command, you can move from one directory to another. In the below example, we are initially in the root directory. we have then used the cd command to change the directory. ls (list files and directories)** The ls command is used to list the contents of a directory. It will list down all the files and folders present in the given directory. If we just type ls in the shell, it will list all the files and directories present in the current directory. We can also provide the directory name as argument to ls command. It will then list all the files and directories inside the given directory. Commands for Manipulating Files There are five basic commands which are used frequently to manipulate files: touch mkdir cp mv rm We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. touch (create new file) The touch command can be used to create an empty new file. This command is very useful for many other purposes but we will discuss the simplest use case of creating a new file. General syntax of using touch command touch mkdir (create new directories) The mkdir command is used to create directories.You can use ls command to verify that the new directory is created. General syntax of using mkdir command mkdir rm (delete files and directories) The rm command can be used to delete files and directories. It is very important to note that this command permanently deletes the files and directories. It's almost impossible to recover these files and directories once you have executed rm command on them successfully. Do run this command with care. General syntax of using rm command: rm Let's try to understand the rm command with an example. We will try to delete the file and directory we created using touch and mkdir command respectively. cp (copy files and directories) The cp command is used to copy files and directories from one location to another. Do note that the cp command doesn't do any change to the original files or directories. The original files or directories and their copy both co-exist after running cp command successfully. General syntax of using cp command: cp We are currently in the '/home/runner' directory. We will use the mkdir command to create a new directory named \"test_directory\". We will now try to copy the \"_test_runner.py\" file to the directory we created just now. Do note that nothing happened to the original \"_test_runner.py\" file. It's still there in the current directory. A new copy of it got created inside the \"test_directory\". We can also use the cp command to copy the whole directory from one location to another. Let's try to understand this with an example. We again used the mkdir command to create a new directory called \"another_directory\". We then used the cp command along with an additional argument '-r' to copy the \"test_directory\". mv (move files and directories) The mv command can either be used to move files or directories from one location to another or it can be used to rename files or directories. Do note that moving files and copying them are very different. When you move the files or directories, the original copy is lost. General syntax of using mv command: mv In this example, we will use the mv command to move the \"_test_runner.py\" file to \"test_directory\". In this case, this file already exists in \"test_directory\". The mv command will just replace it. Do note that the original file doesn't exist in the current directory after mv command ran successfully. We can also use the mv command to move a directory from one location to another. In this case, we do not need to use the '-r' flag that we did while using the cp command. Do note that the original directory will not exist if we use mv command. One of the important uses of the mv command is to rename files and directories. Let's see how we can use this command for renaming. We have first changed our location to \"test_directory\". We then use the mv command to rename the \"\"_test_runner.py\" file to \"test.py\". Commands for Viewing Files There are five basic commands which are used frequently to view the files: cat head tail more less We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. We will create a new file called \"numbers.txt\" and insert numbers from 1 to 100 in this file. Each number will be in a separate line. Do not worry about the above command now. It's an advanced command which is used to generate numbers. We have then used a redirection operator to push these numbers to the file. We will be discussing I/O redirection in the later sections. cat The most simplest use of cat command is to print the contents of the file on your output screen. This command is very useful and can be used for many other purposes. We will study about other use cases later. You can try to run the above command and you will see numbers being printed from 1 to 100 on your screen. You will need to scroll up to view all the numbers. head The head command displays the first 10 lines of the file by default. We can include additional arguments to display as many lines as we want from the top. In this example, we are only able to see the first 10 lines from the file when we use the head command. By default, head command will only display the first 10 lines. If we want to specify the number of lines we want to see from start, use the '-n' argument to provide the input. tail The tail command displays the last 10 lines of the file by default. We can include additional arguments to display as many lines as we want from the end of the file. By default, the tail command will only display the last 10 lines. If we want to specify the number of lines we want to see from the end, use '-n' argument to provide the input. In this example, we are only able to see the last 5 lines from the file when we use the tail command with explicit -n option. more More command displays the contents of a file or a command output, displaying one screen at a time in case the file is large (Eg: log files). It also allows forward navigation and limited backward navigation in the file. More command displays as much as can fit on the current screen and waits for user input to advance. Forward navigation can be done by pressing Enter, which advances the output by one line and Space, which advances the output by one screen. less Less command is an improved version of more. It displays the contents of a file or a command output, one page at a time. It allows backward navigation as well as forward navigation in the file and also has search options. We can use arrow keys for advancing backward or forward by one line. For moving forward by one page, press Space and for moving backward by one page, press b on your keyboard. You can go to the beginning and the end of a file instantly. Echo Command in Linux The echo command is one of the simplest commands that is used in the shell. This command is equivalent to what we have in other programming languages. The echo command prints the given input string on the screen. Text Processing Commands In the previous section, we learned how to view the content of a file. In many cases, we will be interested in performing the below operations: Print only the lines which contain a particular word(s) Replace a particular word with another word in a file Sort the lines in a particular order There are three basic commands which are used frequently to process texts: grep sed sort We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. We will create a new file called \"numbers.txt\" and insert numbers from 1 to 10 in this file. Each number will be in a separate line. grep The grep command in its simplest form can be used to search particular words in a text file. It will display all the lines in a file that contains a particular input. The word we want to search is provided as an input to the grep command. General syntax of using grep command: grep In this example, we are trying to search for a string \"1\" in this file. The grep command outputs the lines where it found this string. sed The sed command in its simplest form can be used to replace a text in a file. General syntax of using the sed command for replacement: sed 's///' Let's try to replace each occurrence of \"1\" in the file with \"3\" using sed command. The content of the file will not change in the above example. To do so, we have to use an extra argument '-i' so that the changes are reflected back in the file. sort The sort command can be used to sort the input provided to it as an argument. By default, it will sort in increasing order. Let's first see the content of the file before trying to sort it. Now, we will try to sort the file using the sort command. The sort command sorts the content in lexicographical order. The content of the file will not change in the above example. I/O Redirection Each open file gets assigned a file descriptor. A file descriptor is an unique identifier for open files in the system. There are always three default files open, stdin (the keyboard), stdout (the screen), and stderr (error messages output to the screen). These files can be redirected. Everything is a file in linux - https://unix.stackexchange.com/questions/225537/everything-is-a-file Till now, we have displayed all the output on the screen which is the standard output. We can use some special operators to redirect the output of the command to files or even to the input of other commands. I/O redirection is a very powerful feature. In the below example, we have used the '>' operator to redirect the output of ls command to output.txt file. In the below example, we have redirected the output from echo command to a file. We can also redirect the output of a command as an input to another command. This is possible with the help of pipes. In the below example, we have passed the output of cat command as an input to grep command using pipe(|) operator. In the below example, we have passed the output of sort command as an input to uniq command using pipe(|) operator. The uniq command only prints the unique numbers from the input. I/O redirection - https://tldp.org/LDP/abs/html/io-redirection.html","title":"Command Line Basics"},{"location":"level101/linux_basics/command_line_basics/#command-line-basics","text":"","title":"Command Line Basics"},{"location":"level101/linux_basics/command_line_basics/#lab-environment-setup","text":"One can use an online bash interpreter to run all the commands that are provided as examples in this course. This will also help you in getting a hands-on experience of various linux commands. REPL is one of the popular online bash interpreters for running linux commands. We will be using it for running all the commands mentioned in this course.","title":"Lab Environment Setup"},{"location":"level101/linux_basics/command_line_basics/#what-is-a-command","text":"A command is a program that tells the operating system to perform specific work. Programs are stored as files in linux. Therefore, a command is also a file which is stored somewhere on the disk. Commands may also take additional arguments as input from the user. These arguments are called command line arguments. Knowing how to use the commands is important and there are many ways to get help in Linux, especially for commands. Almost every command will have some form of documentation, most commands will have a command-line argument -h or --help that will display a reasonable amount of documentation. But the most popular documentation system in Linux is called man pages - short for manual pages. Using --help to show the documentation for ls command.","title":"What is a Command"},{"location":"level101/linux_basics/command_line_basics/#file-system-organization","text":"The linux file system has a hierarchical (or tree-like) structure with its highest level directory called root ( denoted by / ). Directories present inside the root directory stores file related to the system. These directories in turn can either store system files or application files or user related files. bin | The executable program of most commonly used commands reside in bin directory sbin | This directory contains programs used for system administration. home | This directory contains user related files and directories. lib | This directory contains all the library files etc | This directory contains all the system configuration files proc | This directory contains files related to the running processes on the system dev | This directory contains files related to devices on the system mnt | This directory contains files related to mounted devices on the system tmp | This directory is used to store temporary files on the system usr | This directory is used to store application programs on the system","title":"File System Organization"},{"location":"level101/linux_basics/command_line_basics/#commands-for-navigating-the-file-system","text":"There are three basic commands which are used frequently to navigate the file system: ls pwd cd We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell.","title":"Commands for Navigating the File System"},{"location":"level101/linux_basics/command_line_basics/#pwd-print-working-directory","text":"At any given moment of time, we will be standing in a certain directory. To get the name of the directory in which we are standing, we can use the pwd command in linux. We will now use the cd command to move to a different directory and then print the working directory.","title":"pwd (print working directory)"},{"location":"level101/linux_basics/command_line_basics/#cd-change-directory","text":"The cd command can be used to change the working directory. Using the command, you can move from one directory to another. In the below example, we are initially in the root directory. we have then used the cd command to change the directory.","title":"cd (change directory)"},{"location":"level101/linux_basics/command_line_basics/#ls-list-files-and-directories","text":"The ls command is used to list the contents of a directory. It will list down all the files and folders present in the given directory. If we just type ls in the shell, it will list all the files and directories present in the current directory. We can also provide the directory name as argument to ls command. It will then list all the files and directories inside the given directory.","title":"ls (list files and directories)**"},{"location":"level101/linux_basics/command_line_basics/#commands-for-manipulating-files","text":"There are five basic commands which are used frequently to manipulate files: touch mkdir cp mv rm We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell.","title":"Commands for Manipulating Files"},{"location":"level101/linux_basics/command_line_basics/#touch-create-new-file","text":"The touch command can be used to create an empty new file. This command is very useful for many other purposes but we will discuss the simplest use case of creating a new file. General syntax of using touch command touch ","title":"touch (create new file)"},{"location":"level101/linux_basics/command_line_basics/#mkdir-create-new-directories","text":"The mkdir command is used to create directories.You can use ls command to verify that the new directory is created. General syntax of using mkdir command mkdir ","title":"mkdir (create new directories)"},{"location":"level101/linux_basics/command_line_basics/#rm-delete-files-and-directories","text":"The rm command can be used to delete files and directories. It is very important to note that this command permanently deletes the files and directories. It's almost impossible to recover these files and directories once you have executed rm command on them successfully. Do run this command with care. General syntax of using rm command: rm Let's try to understand the rm command with an example. We will try to delete the file and directory we created using touch and mkdir command respectively.","title":"rm (delete files and directories)"},{"location":"level101/linux_basics/command_line_basics/#cp-copy-files-and-directories","text":"The cp command is used to copy files and directories from one location to another. Do note that the cp command doesn't do any change to the original files or directories. The original files or directories and their copy both co-exist after running cp command successfully. General syntax of using cp command: cp We are currently in the '/home/runner' directory. We will use the mkdir command to create a new directory named \"test_directory\". We will now try to copy the \"_test_runner.py\" file to the directory we created just now. Do note that nothing happened to the original \"_test_runner.py\" file. It's still there in the current directory. A new copy of it got created inside the \"test_directory\". We can also use the cp command to copy the whole directory from one location to another. Let's try to understand this with an example. We again used the mkdir command to create a new directory called \"another_directory\". We then used the cp command along with an additional argument '-r' to copy the \"test_directory\". mv (move files and directories) The mv command can either be used to move files or directories from one location to another or it can be used to rename files or directories. Do note that moving files and copying them are very different. When you move the files or directories, the original copy is lost. General syntax of using mv command: mv In this example, we will use the mv command to move the \"_test_runner.py\" file to \"test_directory\". In this case, this file already exists in \"test_directory\". The mv command will just replace it. Do note that the original file doesn't exist in the current directory after mv command ran successfully. We can also use the mv command to move a directory from one location to another. In this case, we do not need to use the '-r' flag that we did while using the cp command. Do note that the original directory will not exist if we use mv command. One of the important uses of the mv command is to rename files and directories. Let's see how we can use this command for renaming. We have first changed our location to \"test_directory\". We then use the mv command to rename the \"\"_test_runner.py\" file to \"test.py\".","title":"cp (copy files and directories)"},{"location":"level101/linux_basics/command_line_basics/#commands-for-viewing-files","text":"There are five basic commands which are used frequently to view the files: cat head tail more less We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. We will create a new file called \"numbers.txt\" and insert numbers from 1 to 100 in this file. Each number will be in a separate line. Do not worry about the above command now. It's an advanced command which is used to generate numbers. We have then used a redirection operator to push these numbers to the file. We will be discussing I/O redirection in the later sections.","title":"Commands for Viewing Files"},{"location":"level101/linux_basics/command_line_basics/#cat","text":"The most simplest use of cat command is to print the contents of the file on your output screen. This command is very useful and can be used for many other purposes. We will study about other use cases later. You can try to run the above command and you will see numbers being printed from 1 to 100 on your screen. You will need to scroll up to view all the numbers.","title":"cat"},{"location":"level101/linux_basics/command_line_basics/#head","text":"The head command displays the first 10 lines of the file by default. We can include additional arguments to display as many lines as we want from the top. In this example, we are only able to see the first 10 lines from the file when we use the head command. By default, head command will only display the first 10 lines. If we want to specify the number of lines we want to see from start, use the '-n' argument to provide the input.","title":"head"},{"location":"level101/linux_basics/command_line_basics/#tail","text":"The tail command displays the last 10 lines of the file by default. We can include additional arguments to display as many lines as we want from the end of the file. By default, the tail command will only display the last 10 lines. If we want to specify the number of lines we want to see from the end, use '-n' argument to provide the input. In this example, we are only able to see the last 5 lines from the file when we use the tail command with explicit -n option.","title":"tail"},{"location":"level101/linux_basics/command_line_basics/#more","text":"More command displays the contents of a file or a command output, displaying one screen at a time in case the file is large (Eg: log files). It also allows forward navigation and limited backward navigation in the file. More command displays as much as can fit on the current screen and waits for user input to advance. Forward navigation can be done by pressing Enter, which advances the output by one line and Space, which advances the output by one screen.","title":"more"},{"location":"level101/linux_basics/command_line_basics/#less","text":"Less command is an improved version of more. It displays the contents of a file or a command output, one page at a time. It allows backward navigation as well as forward navigation in the file and also has search options. We can use arrow keys for advancing backward or forward by one line. For moving forward by one page, press Space and for moving backward by one page, press b on your keyboard. You can go to the beginning and the end of a file instantly.","title":"less"},{"location":"level101/linux_basics/command_line_basics/#echo-command-in-linux","text":"The echo command is one of the simplest commands that is used in the shell. This command is equivalent to what we have in other programming languages. The echo command prints the given input string on the screen.","title":"Echo Command in Linux"},{"location":"level101/linux_basics/command_line_basics/#text-processing-commands","text":"In the previous section, we learned how to view the content of a file. In many cases, we will be interested in performing the below operations: Print only the lines which contain a particular word(s) Replace a particular word with another word in a file Sort the lines in a particular order There are three basic commands which are used frequently to process texts: grep sed sort We will now try to understand what each command does and how to use these commands. You should also practice the given examples on the online bash shell. We will create a new file called \"numbers.txt\" and insert numbers from 1 to 10 in this file. Each number will be in a separate line.","title":"Text Processing Commands"},{"location":"level101/linux_basics/command_line_basics/#grep","text":"The grep command in its simplest form can be used to search particular words in a text file. It will display all the lines in a file that contains a particular input. The word we want to search is provided as an input to the grep command. General syntax of using grep command: grep In this example, we are trying to search for a string \"1\" in this file. The grep command outputs the lines where it found this string.","title":"grep"},{"location":"level101/linux_basics/command_line_basics/#sed","text":"The sed command in its simplest form can be used to replace a text in a file. General syntax of using the sed command for replacement: sed 's///' Let's try to replace each occurrence of \"1\" in the file with \"3\" using sed command. The content of the file will not change in the above example. To do so, we have to use an extra argument '-i' so that the changes are reflected back in the file.","title":"sed"},{"location":"level101/linux_basics/command_line_basics/#sort","text":"The sort command can be used to sort the input provided to it as an argument. By default, it will sort in increasing order. Let's first see the content of the file before trying to sort it. Now, we will try to sort the file using the sort command. The sort command sorts the content in lexicographical order. The content of the file will not change in the above example.","title":"sort"},{"location":"level101/linux_basics/command_line_basics/#io-redirection","text":"Each open file gets assigned a file descriptor. A file descriptor is an unique identifier for open files in the system. There are always three default files open, stdin (the keyboard), stdout (the screen), and stderr (error messages output to the screen). These files can be redirected. Everything is a file in linux - https://unix.stackexchange.com/questions/225537/everything-is-a-file Till now, we have displayed all the output on the screen which is the standard output. We can use some special operators to redirect the output of the command to files or even to the input of other commands. I/O redirection is a very powerful feature. In the below example, we have used the '>' operator to redirect the output of ls command to output.txt file. In the below example, we have redirected the output from echo command to a file. We can also redirect the output of a command as an input to another command. This is possible with the help of pipes. In the below example, we have passed the output of cat command as an input to grep command using pipe(|) operator. In the below example, we have passed the output of sort command as an input to uniq command using pipe(|) operator. The uniq command only prints the unique numbers from the input. I/O redirection - https://tldp.org/LDP/abs/html/io-redirection.html","title":"I/O Redirection"},{"location":"level101/linux_basics/conclusion/","text":"Conclusion We have covered the basics of Linux operating systems and basic commands used in linux. We have also covered the Linux server administration commands. We hope that this course will make it easier for you to operate on the command line. Applications in SRE Role As a SRE, you will be required to perform some general tasks on these Linux servers. You will also be using the command line when you are troubleshooting issues. Moving from one location to another in the filesystem will require the help of ls , pwd and cd commands. You may need to search some specific information in the log files. grep command would be very useful here. I/O redirection will become handy if you want to store the output in a file or pass it as an input to another command. tail command is very useful to view the latest data in the log file. Different users will have different permissions depending on their roles. We will also not want everyone in the company to access our servers for security reasons. Users permissions can be restricted with chown , chmod and chgrp commands. ssh is one of the most frequently used commands for a SRE. Logging into servers and troubleshooting along with performing basic administration tasks will only be possible if we are able to login into the server. What if we want to run an apache server or nginx on a server? We will first install it using the package manager. Package management commands become important here. Managing services on servers is another critical responsibility of a SRE. Systemd related commands can help in troubleshooting issues. If a service goes down, we can start it using systemctl start command. We can also stop a service in case it is not needed. Monitoring is another core responsibility of a SRE. Memory and CPU are two important system level metrics which should be monitored. Commands like top and free are quite helpful here. If a service is throwing an error, how do we find out the root cause of the error ? We will certainly need to check logs to find out the whole stack trace of the error. The log file will also tell us the number of times the error has occurred along with time when it started. Useful Courses and tutorials Edx basic linux commands course Edx Red Hat Enterprise Linux Course https://linuxcommand.org/lc3_learning_the_shell.php","title":"Conclusion"},{"location":"level101/linux_basics/conclusion/#conclusion","text":"We have covered the basics of Linux operating systems and basic commands used in linux. We have also covered the Linux server administration commands. We hope that this course will make it easier for you to operate on the command line.","title":"Conclusion"},{"location":"level101/linux_basics/conclusion/#applications-in-sre-role","text":"As a SRE, you will be required to perform some general tasks on these Linux servers. You will also be using the command line when you are troubleshooting issues. Moving from one location to another in the filesystem will require the help of ls , pwd and cd commands. You may need to search some specific information in the log files. grep command would be very useful here. I/O redirection will become handy if you want to store the output in a file or pass it as an input to another command. tail command is very useful to view the latest data in the log file. Different users will have different permissions depending on their roles. We will also not want everyone in the company to access our servers for security reasons. Users permissions can be restricted with chown , chmod and chgrp commands. ssh is one of the most frequently used commands for a SRE. Logging into servers and troubleshooting along with performing basic administration tasks will only be possible if we are able to login into the server. What if we want to run an apache server or nginx on a server? We will first install it using the package manager. Package management commands become important here. Managing services on servers is another critical responsibility of a SRE. Systemd related commands can help in troubleshooting issues. If a service goes down, we can start it using systemctl start command. We can also stop a service in case it is not needed. Monitoring is another core responsibility of a SRE. Memory and CPU are two important system level metrics which should be monitored. Commands like top and free are quite helpful here. If a service is throwing an error, how do we find out the root cause of the error ? We will certainly need to check logs to find out the whole stack trace of the error. The log file will also tell us the number of times the error has occurred along with time when it started.","title":"Applications in SRE Role"},{"location":"level101/linux_basics/conclusion/#useful-courses-and-tutorials","text":"Edx basic linux commands course Edx Red Hat Enterprise Linux Course https://linuxcommand.org/lc3_learning_the_shell.php","title":"Useful Courses and tutorials"},{"location":"level101/linux_basics/intro/","text":"Linux Basics Introduction Prerequisites Should be comfortable in using any operating systems like Windows, Linux or Mac Expected to have fundamental knowledge of operating systems What to expect from this course This course is divided into three parts. In the first part, we cover the fundamentals of Linux operating systems. We will talk about Linux architecture, Linux distributions and uses of Linux operating systems. We will also talk about the difference between GUI and CLI. In the second part, we cover some basic commands used in Linux. We will focus on commands used for navigating the file system, viewing and manipulating files, I/O redirection etc. In the third part, we cover Linux system administration. This includes day to day tasks performed by Linux admins, like managing users/groups, managing file permissions, monitoring system performance, log files etc. In the second and third part, we will be taking examples to understand the concepts. What is not covered under this course We are not covering advanced Linux commands and bash scripting in this course. We will also not be covering Linux internals. Course Contents The following topics has been covered in this course: Introduction to Linux What are Linux Operating Systems What are popular Linux distributions Uses of Linux Operating Systems Linux Architecture Graphical user interface (GUI) vs Command line interface (CLI) Command Line Basics Lab Environment Setup What is a Command File System Organization Navigating File System Manipulating Files Viewing Files Echo Command Text Processing Commands I/O Redirection Linux system administration Lab Environment Setup User/Groups management Becoming a Superuser File Permissions SSH Command Package Management Process Management Memory Management Daemons and Systemd Logs Conclusion Applications in SRE Role Useful Courses and tutorials What are Linux operating systems Most of us are familiar with the Windows operating system used in more than 75% of the personal computers. The Windows operating systems are based on Windows NT kernel. A kernel is the most important part of an operating system - it performs important functions like process management, memory management, filesystem management etc. Linux operating systems are based on the Linux kernel. A Linux based operating system will consist of Linux kernel, GUI/CLI, system libraries and system utilities. The Linux kernel was independently developed and released by Linus Torvalds. The Linux kernel is free and open-source - https://github.com/torvalds/linux Linux is a kernel and and not a complete operating system. Linux kernel is combined with GNU system to make a complete operating system. Therefore, linux based operating systems are also called as GNU/Linux systems. GNU is an extensive collection of free softwares like compiler, debugger, C library etc. Linux and the GNU System History of Linux - https://en.wikipedia.org/wiki/History_of_Linux What are popular Linux distributions A Linux distribution(distro) is an operating system based on the Linux kernel and a package management system. A package management system consists of tools that help in installing, upgrading, configuring and removing softwares on the operating system. Software are usually adopted to a distribution and are packaged in a distro specific format. These packages are available through a distro specific repository. Packages are installed and managed in the operating system by a package manager. List of popular Linux distributions: Fedora Ubuntu Debian Centos Red Hat Enterprise Linux Suse Arch Linux Packaging systems Distributions Package manager Debian style (.deb) Debian, Ubuntu APT Red Hat style (.rpm) Fedora, CentOS, Red Hat Enterprise Linux YUM Linux Architecture The Linux kernel is monolithic in nature. System calls are used to interact with the Linux kernel space. Kernel code can only be executed in the kernel mode. Non-kernel code is executed in the user mode. Device drivers are used to communicate with the hardware devices. Uses of Linux Operating Systems Operating system based on Linux kernel are widely used in: Personal computers Servers Mobile phones - Android is based on Linux operating system Embedded devices - watches, televisions, traffic lights etc Satellites Network devices - routers, switches etc. Graphical user interface (GUI) vs Command line interface (CLI) A user interacts with a computer with the help of user interfaces. The user interface can be either GUI or CLI. Graphical user interface allows a user to interact with the computer using graphics such as icons and images. When a user clicks on an icon to open an application on a computer, he or she is actually using the GUI. It's easy to perform tasks using GUI. Command line interface allows a user to interact with the computer using commands. A user types the command in a terminal and the system helps in executing these commands. A new user with experience on GUI may find it difficult to interact with CLI as he/she needs to be aware of the commands to perform a particular operation. Shell vs Terminal Shell is a program that takes commands from the users and gives them to the operating system for processing. Shell is an example of a CLI (command line interface). Bash is one of the most popular shell programs available on Linux servers. Other popular shell programs are zsh, ksh and tcsh. Terminal is a program that opens a window and lets you interact with the shell. Some popular examples of terminals are gnome-terminal, xterm, konsole etc. Linux users do use the terms shell, terminal, prompt, console etc. interchangeably. In simple terms, these all refer to a way of taking commands from the user.","title":"Introduction"},{"location":"level101/linux_basics/intro/#linux-basics","text":"","title":"Linux Basics"},{"location":"level101/linux_basics/intro/#introduction","text":"","title":"Introduction"},{"location":"level101/linux_basics/intro/#prerequisites","text":"Should be comfortable in using any operating systems like Windows, Linux or Mac Expected to have fundamental knowledge of operating systems","title":"Prerequisites"},{"location":"level101/linux_basics/intro/#what-to-expect-from-this-course","text":"This course is divided into three parts. In the first part, we cover the fundamentals of Linux operating systems. We will talk about Linux architecture, Linux distributions and uses of Linux operating systems. We will also talk about the difference between GUI and CLI. In the second part, we cover some basic commands used in Linux. We will focus on commands used for navigating the file system, viewing and manipulating files, I/O redirection etc. In the third part, we cover Linux system administration. This includes day to day tasks performed by Linux admins, like managing users/groups, managing file permissions, monitoring system performance, log files etc. In the second and third part, we will be taking examples to understand the concepts.","title":"What to expect from this course"},{"location":"level101/linux_basics/intro/#what-is-not-covered-under-this-course","text":"We are not covering advanced Linux commands and bash scripting in this course. We will also not be covering Linux internals.","title":"What is not covered under this course"},{"location":"level101/linux_basics/intro/#course-contents","text":"The following topics has been covered in this course: Introduction to Linux What are Linux Operating Systems What are popular Linux distributions Uses of Linux Operating Systems Linux Architecture Graphical user interface (GUI) vs Command line interface (CLI) Command Line Basics Lab Environment Setup What is a Command File System Organization Navigating File System Manipulating Files Viewing Files Echo Command Text Processing Commands I/O Redirection Linux system administration Lab Environment Setup User/Groups management Becoming a Superuser File Permissions SSH Command Package Management Process Management Memory Management Daemons and Systemd Logs Conclusion Applications in SRE Role Useful Courses and tutorials","title":"Course Contents"},{"location":"level101/linux_basics/intro/#what-are-linux-operating-systems","text":"Most of us are familiar with the Windows operating system used in more than 75% of the personal computers. The Windows operating systems are based on Windows NT kernel. A kernel is the most important part of an operating system - it performs important functions like process management, memory management, filesystem management etc. Linux operating systems are based on the Linux kernel. A Linux based operating system will consist of Linux kernel, GUI/CLI, system libraries and system utilities. The Linux kernel was independently developed and released by Linus Torvalds. The Linux kernel is free and open-source - https://github.com/torvalds/linux Linux is a kernel and and not a complete operating system. Linux kernel is combined with GNU system to make a complete operating system. Therefore, linux based operating systems are also called as GNU/Linux systems. GNU is an extensive collection of free softwares like compiler, debugger, C library etc. Linux and the GNU System History of Linux - https://en.wikipedia.org/wiki/History_of_Linux","title":"What are Linux operating systems"},{"location":"level101/linux_basics/intro/#what-are-popular-linux-distributions","text":"A Linux distribution(distro) is an operating system based on the Linux kernel and a package management system. A package management system consists of tools that help in installing, upgrading, configuring and removing softwares on the operating system. Software are usually adopted to a distribution and are packaged in a distro specific format. These packages are available through a distro specific repository. Packages are installed and managed in the operating system by a package manager. List of popular Linux distributions: Fedora Ubuntu Debian Centos Red Hat Enterprise Linux Suse Arch Linux Packaging systems Distributions Package manager Debian style (.deb) Debian, Ubuntu APT Red Hat style (.rpm) Fedora, CentOS, Red Hat Enterprise Linux YUM","title":"What are popular Linux distributions"},{"location":"level101/linux_basics/intro/#linux-architecture","text":"The Linux kernel is monolithic in nature. System calls are used to interact with the Linux kernel space. Kernel code can only be executed in the kernel mode. Non-kernel code is executed in the user mode. Device drivers are used to communicate with the hardware devices.","title":"Linux Architecture"},{"location":"level101/linux_basics/intro/#uses-of-linux-operating-systems","text":"Operating system based on Linux kernel are widely used in: Personal computers Servers Mobile phones - Android is based on Linux operating system Embedded devices - watches, televisions, traffic lights etc Satellites Network devices - routers, switches etc.","title":"Uses of Linux Operating Systems"},{"location":"level101/linux_basics/intro/#graphical-user-interface-gui-vs-command-line-interface-cli","text":"A user interacts with a computer with the help of user interfaces. The user interface can be either GUI or CLI. Graphical user interface allows a user to interact with the computer using graphics such as icons and images. When a user clicks on an icon to open an application on a computer, he or she is actually using the GUI. It's easy to perform tasks using GUI. Command line interface allows a user to interact with the computer using commands. A user types the command in a terminal and the system helps in executing these commands. A new user with experience on GUI may find it difficult to interact with CLI as he/she needs to be aware of the commands to perform a particular operation.","title":"Graphical user interface (GUI) vs Command line interface (CLI)"},{"location":"level101/linux_basics/intro/#shell-vs-terminal","text":"Shell is a program that takes commands from the users and gives them to the operating system for processing. Shell is an example of a CLI (command line interface). Bash is one of the most popular shell programs available on Linux servers. Other popular shell programs are zsh, ksh and tcsh. Terminal is a program that opens a window and lets you interact with the shell. Some popular examples of terminals are gnome-terminal, xterm, konsole etc. Linux users do use the terms shell, terminal, prompt, console etc. interchangeably. In simple terms, these all refer to a way of taking commands from the user.","title":"Shell vs Terminal"},{"location":"level101/linux_basics/linux_server_administration/","text":"Linux Server Administration In this course will try to cover some of the common tasks that a linux server administrator performs. We will first try to understand what a particular command does and then try to understand the commands using examples. Do keep in mind that it's very important to practice the Linux commands on your own. Lab Environment Setup Install docker on your system - https://docs.docker.com/engine/install/ We will be running all the commands on Red Hat Enterprise Linux (RHEL) 8 system. We will run most of the commands used in this module in the above Docker container. Multi-User Operating Systems An operating system is considered as multi-user if it allows multiple people/users to use a computer and not affect each other's files and preferences. Linux based operating systems are multi-user in nature as it allows multiple users to access the system at the same time. A typical computer will only have one keyboard and monitor but multiple users can log in via SSH if the computer is connected to the network. We will cover more about SSH later. As a server administrator, we are mostly concerned with the Linux servers which are physically present at a very large distance from us. We can connect to these servers with the help of remote login methods like SSH. Since Linux supports multiple users, we need to have a method which can protect the users from each other. One user should not be able to access and modify files of other users User/Group Management Users in Linux has an associated user ID called UID attached to them. Users also has a home directory and a login shell associated with them. A group is a collection of one or more users. A group makes it easier to share permissions among a group of users. Each group has a group ID called GID associated with it. id command id command can be used to find the uid and gid associated with an user. It also lists down the groups to which the user belongs to. The uid and gid associated with the root user is 0. A good way to find out the current user in Linux is to use the whoami command. \"root\" user or superuser is the most privileged user with unrestricted access to all the resources on the system. It has UID 0 Important files associated with users/groups /etc/passwd Stores the user name, the uid, the gid, the home directory, the login shell etc /etc/shadow Stores the password associated with the users /etc/group Stores information about different groups on the system If you want to understand each filed discussed in the above outputs, you can go through below links: https://tldp.org/LDP/lame/LAME/linux-admin-made-easy/shadow-file-formats.html https://tldp.org/HOWTO/User-Authentication-HOWTO/x71.html Important commands for managing users Some of the commands which are used frequently to manage users/groups on Linux are following: useradd - Creates a new user passwd - Adds or modifies passwords for a user usermod - Modifies attributes of an user userdel - Deletes an user useradd The useradd command adds a new user in Linux. We will create a new user 'shivam'. We will also verify that the user has been created by tailing the /etc/passwd file. The uid and gid are 1000 for the newly created user. The home directory assigned to the user is /home/shivam and the login shell assigned is /bin/bash. Do note that the user home directory and login shell can be modified later on. If we do not specify any value for attributes like home directory or login shell, default values will be assigned to the user. We can also override these default values when creating a new user. passwd The passwd command is used to create or modify passwords for a user. In the above examples, we have not assigned any password for users 'shivam' or 'amit' while creating them. \"!!\" in an account entry in shadow means the account of an user has been created, but not yet given a password. Let's now try to create a password for user \"shivam\". Do remember the password as we will be later using examples where it will be useful. Also, let's change the password for the root user now. When we switch from a normal user to root user, it will request you for a password. Also, when you login using root user, the password will be asked. usermod The usermod command is used to modify the attributes of an user like the home directory or the shell. Let's try to modify the login shell of user \"amit\" to \"/bin/bash\". In a similar way, you can also modify many other attributes for a user. Try 'usermod -h' for a list of attributes you can modify. userdel The userdel command is used to remove a user on Linux. Once we remove a user, all the information related to that user will be removed. Let's try to delete the user \"amit\". After deleting the user, you will not find the entry for that user in \"/etc/passwd\" or \"/etc/shadow\" file. Important commands for managing groups Commands for managing groups are quite similar to the commands used for managing users. Each command is not explained in detail here as they are quite similar. You can try running these commands on your system. groupadd \\ Creates a new group groupmod \\ Modifies attributes of a group groupdel \\ Deletes a group gpasswd \\ Modifies password for group We will now try to add user \"shivam\" to the group we have created above. Becoming a Superuser Before running the below commands, do make sure that you have set up a password for user \"shivam\" and user \"root\" using the passwd command described in the above section. The su command can be used to switch users in Linux. Let's now try to switch to user \"shivam\". Let's now try to open the \"/etc/shadow\" file. The operating system didn't allow the user \"shivam\" to read the content of the \"/etc/shadow\" file. This is an important file in Linux which stores the passwords of users. This file can only be accessed by root or users who have the superuser privileges. The sudo command allows a user to run commands with the security privileges of the root user. Do remember that the root user has all the privileges on a system. We can also use su command to switch to the root user and open the above file but doing that will require the password of the root user. An alternative way which is preferred on most modern operating systems is to use sudo command for becoming a superuser. Using this way, a user has to enter his/her password and they need to be a part of the sudo group. How to provide superpriveleges to other users ? Let's first switch to the root user using su command. Do note that using the below command will need you to enter the password for the root user. In case, you forgot to set a password for the root user, type \"exit\" and you will be back as the root user. Now, set up a password using the passwd command. The file /etc/sudoers holds the names of users permitted to invoke sudo . In redhat operating systems, this file is not present by default. We will need to install sudo. We will discuss the yum command in detail in later sections. Try to open the \"/etc/sudoers\" file on the system. The file has a lot of information. This file stores the rules that users must follow when running the sudo command. For example, root is allowed to run any commands from anywhere. One easy way of providing root access to users is to add them to a group which has permissions to run all the commands. \"wheel\" is a group in redhat Linux with such privileges. Let's add the user \"shivam\" to this group so that it also has sudo privileges. Let's now switch back to user \"shivam\" and try to access the \"/etc/shadow\" file. We need to use sudo before running the command since it can only be accessed with the sudo privileges. We have already given sudo privileges to user \u201cshivam\u201d by adding him to the group \u201cwheel\u201d. File Permissions On a Linux operating system, each file and directory is assigned access permissions for the owner of the file, the members of a group of related users and everybody else. This is to make sure that one user is not allowed to access the files and resources of another user. To see the permissions of a file, we can use the ls command. Let's look at the permissions of /etc/passwd file. Let's go over some of the important fields in the output that are related to file permissions. Chmod command The chmod command is used to modify files and directories permissions in Linux. The chmod command accepts permissions in as a numerical argument. We can think of permission as a series of bits with 1 representing True or allowed and 0 representing False or not allowed. Permission rwx Binary Decimal Read, write and execute rwx 111 7 Read and write rw- 110 6 Read and execute r-x 101 5 Read only r-- 100 4 Write and execute -wx 011 3 Write only -w- 010 2 Execute only --x 001 1 None --- 000 0 We will now create a new file and check the permission of the file. The group owner doesn't have the permission to write to this file. Let's give the group owner or root the permission to write to it using chmod command. Chmod command can be also used to change the permissions of a directory in the similar way. Chown command The chown command is used to change the owner of files or directories in Linux. Command syntax: chown \\ \\ In case, we do not have sudo privileges, we need to use sudo command . Let's switch to user 'shivam' and try changing the owner. We have also changed the owner of the file to root before running the below command. Chown command can also be used to change the owner of a directory in the similar way. Chgrp command The chgrp command can be used to change the group ownership of files or directories in Linux. The syntax is very similar to that of chown command. Chgrp command can also be used to change the owner of a directory in the similar way. SSH Command The ssh command is used for logging into the remote systems, transfer files between systems and for executing commands on a remote machine. SSH stands for secure shell and is used to provide an encrypted secured connection between two hosts over an insecure network like the internet. Reference: https://www.ssh.com/ssh/command/ We will now discuss passwordless authentication which is secure and most commonly used for ssh authentication. Passwordless Authentication Using SSH Using this method, we can ssh into hosts without entering the password. This method is also useful when we want some scripts to perform ssh-related tasks. Passwordless authentication requires the use of a public and private key pair. As the name implies, the public key can be shared with anyone but the private key should be kept private. Lets not get into the details of how this authentication works. You can read more about it here Steps for setting up a passwordless authentication with a remote host: Generating public-private key pair If we already have a key pair stored in \\~/.ssh directory, we will not need to generate keys again. Install openssh package which contains all the commands related to ssh. Generate a key pair using the ssh-keygen command. One can choose the default values for all prompts. After running the ssh-keygen command successfully, we should see two keys present in the \\~/.ssh directory. Id_rsa is the private key and id_rsa.pub is the public key. Do note that the private key can only be read and modified by you. Transferring the public key to the remote host There are multiple ways to transfer the public key to the remote server. We will look at one of the most common ways of doing it using the ssh-copy-id command. Install the openssh-clients package to use ssh-copy-id command. Use the ssh-copy-id command to copy your public key to the remote host. Now, ssh into the remote host using the password authentication. Our public key should be there in \\~/.ssh/authorized_keys now. \\~/.ssh/authorized_key contains a list of public keys. The users associated with these public keys have the ssh access into the remote host. How to run commands on a remote host ? General syntax: ssh \\@\\ \\ How to transfer files from one host to another host ? General syntax: scp \\ \\ Package Management Package management is the process of installing and managing software on the system. We can install the packages which we require from the Linux package distributor. Different distributors use different packaging systems. Packaging systems Distributions Debian style (.deb) Debian, Ubuntu Red Hat style (.rpm) Fedora, CentOS, Red Hat Enterprise Linux Popular Packaging Systems in Linux Command Description yum install \\ Installs a package on your system yum update \\ Updates a package to it's latest available version yum remove \\ Removes a package from your system yum search \\ Searches for a particular keyword DNF is the successor to YUM which is now used in Fedora for installing and managing packages. DNF may replace YUM in the future on all RPM based Linux distributions. We did find an exact match for the keyword httpd when we searched using yum search command. Let's now install the httpd package. After httpd is installed, we will use the yum remove command to remove httpd package. Process Management In this section, we will study about some useful commands that can be used to monitor the processes on Linux systems. ps (process status) The ps command is used to know the information of a process or list of processes. If you get an error \"ps command not found\" while running ps command, do install procps package. ps without any arguments is not very useful. Let's try to list all the processes on the system by using the below command. Reference: https://unix.stackexchange.com/questions/106847/what-does-aux-mean-in-ps-aux We can use an additional argument with ps command to list the information about the process with a specific process ID. We can use grep in combination with ps command to list only specific processes. top The top command is used to show information about Linux processes running on the system in real time. It also shows a summary of the system information. For each process, top lists down the process ID, owner, priority, state, cpu utilization, memory utilization and much more information. It also lists down the memory utilization and cpu utilization of the system as a whole along with system uptime and cpu load average. Memory Management In this section, we will study about some useful commands that can be used to view information about the system memory. free The free command is used to display the memory usage of the system. The command displays the total free and used space available in the RAM along with space occupied by the caches/buffers. free command by default shows the memory usage in kilobytes. We can use an additional argument to get the data in human-readable format. vmstat The vmstat command can be used to display the memory usage along with additional information about io and cpu usage. Checking Disk Space In this section, we will study about some useful commands that can be used to view disk space on Linux. df (disk free) The df command is used to display the free and available space for each mounted file system. du (disk usage) The du command is used to display disk usage of files and directories on the system. The below command can be used to display the top 5 largest directories in the root directory. Daemons A computer program that runs as a background process is called a daemon. Traditionally, the name of daemon processes ended with d - sshd, httpd etc. We cannot interact with a daemon process as they run in the background. Services and daemons are used interchangeably most of the time. Systemd Systemd is a system and service manager for Linux operating systems. Systemd units are the building blocks of systemd. These units are represented by unit configuration files. The below examples shows the unit configuration files available at /usr/lib/systemd/system which are distributed by installed RPM packages. We are more interested in the configuration file that ends with service as these are service units. Managing System Services Service units end with .service file extension. Systemctl command can be used to start/stop/restart the services managed by systemd. Command Description systemctl start name.service Starts a service systemctl stop name.service Stops a service systemctl restart name.service Restarts a service systemctl status name.service Check the status of a service systemctl reload name.service Reload the configuration of a service Logs In this section, we will talk about some important files and directories which can be very useful for viewing system logs and applications logs in Linux. These logs can be very useful when you are troubleshooting on the system.","title":"Server Administration"},{"location":"level101/linux_basics/linux_server_administration/#linux-server-administration","text":"In this course will try to cover some of the common tasks that a linux server administrator performs. We will first try to understand what a particular command does and then try to understand the commands using examples. Do keep in mind that it's very important to practice the Linux commands on your own.","title":"Linux Server Administration"},{"location":"level101/linux_basics/linux_server_administration/#lab-environment-setup","text":"Install docker on your system - https://docs.docker.com/engine/install/ We will be running all the commands on Red Hat Enterprise Linux (RHEL) 8 system. We will run most of the commands used in this module in the above Docker container.","title":"Lab Environment Setup"},{"location":"level101/linux_basics/linux_server_administration/#multi-user-operating-systems","text":"An operating system is considered as multi-user if it allows multiple people/users to use a computer and not affect each other's files and preferences. Linux based operating systems are multi-user in nature as it allows multiple users to access the system at the same time. A typical computer will only have one keyboard and monitor but multiple users can log in via SSH if the computer is connected to the network. We will cover more about SSH later. As a server administrator, we are mostly concerned with the Linux servers which are physically present at a very large distance from us. We can connect to these servers with the help of remote login methods like SSH. Since Linux supports multiple users, we need to have a method which can protect the users from each other. One user should not be able to access and modify files of other users","title":"Multi-User Operating Systems"},{"location":"level101/linux_basics/linux_server_administration/#usergroup-management","text":"Users in Linux has an associated user ID called UID attached to them. Users also has a home directory and a login shell associated with them. A group is a collection of one or more users. A group makes it easier to share permissions among a group of users. Each group has a group ID called GID associated with it.","title":"User/Group Management"},{"location":"level101/linux_basics/linux_server_administration/#id-command","text":"id command can be used to find the uid and gid associated with an user. It also lists down the groups to which the user belongs to. The uid and gid associated with the root user is 0. A good way to find out the current user in Linux is to use the whoami command. \"root\" user or superuser is the most privileged user with unrestricted access to all the resources on the system. It has UID 0","title":"id command"},{"location":"level101/linux_basics/linux_server_administration/#important-files-associated-with-usersgroups","text":"/etc/passwd Stores the user name, the uid, the gid, the home directory, the login shell etc /etc/shadow Stores the password associated with the users /etc/group Stores information about different groups on the system If you want to understand each filed discussed in the above outputs, you can go through below links: https://tldp.org/LDP/lame/LAME/linux-admin-made-easy/shadow-file-formats.html https://tldp.org/HOWTO/User-Authentication-HOWTO/x71.html","title":"Important files associated with users/groups"},{"location":"level101/linux_basics/linux_server_administration/#important-commands-for-managing-users","text":"Some of the commands which are used frequently to manage users/groups on Linux are following: useradd - Creates a new user passwd - Adds or modifies passwords for a user usermod - Modifies attributes of an user userdel - Deletes an user","title":"Important commands for managing users"},{"location":"level101/linux_basics/linux_server_administration/#useradd","text":"The useradd command adds a new user in Linux. We will create a new user 'shivam'. We will also verify that the user has been created by tailing the /etc/passwd file. The uid and gid are 1000 for the newly created user. The home directory assigned to the user is /home/shivam and the login shell assigned is /bin/bash. Do note that the user home directory and login shell can be modified later on. If we do not specify any value for attributes like home directory or login shell, default values will be assigned to the user. We can also override these default values when creating a new user.","title":"useradd"},{"location":"level101/linux_basics/linux_server_administration/#passwd","text":"The passwd command is used to create or modify passwords for a user. In the above examples, we have not assigned any password for users 'shivam' or 'amit' while creating them. \"!!\" in an account entry in shadow means the account of an user has been created, but not yet given a password. Let's now try to create a password for user \"shivam\". Do remember the password as we will be later using examples where it will be useful. Also, let's change the password for the root user now. When we switch from a normal user to root user, it will request you for a password. Also, when you login using root user, the password will be asked.","title":"passwd"},{"location":"level101/linux_basics/linux_server_administration/#usermod","text":"The usermod command is used to modify the attributes of an user like the home directory or the shell. Let's try to modify the login shell of user \"amit\" to \"/bin/bash\". In a similar way, you can also modify many other attributes for a user. Try 'usermod -h' for a list of attributes you can modify.","title":"usermod"},{"location":"level101/linux_basics/linux_server_administration/#userdel","text":"The userdel command is used to remove a user on Linux. Once we remove a user, all the information related to that user will be removed. Let's try to delete the user \"amit\". After deleting the user, you will not find the entry for that user in \"/etc/passwd\" or \"/etc/shadow\" file.","title":"userdel"},{"location":"level101/linux_basics/linux_server_administration/#important-commands-for-managing-groups","text":"Commands for managing groups are quite similar to the commands used for managing users. Each command is not explained in detail here as they are quite similar. You can try running these commands on your system. groupadd \\ Creates a new group groupmod \\ Modifies attributes of a group groupdel \\ Deletes a group gpasswd \\ Modifies password for group We will now try to add user \"shivam\" to the group we have created above.","title":"Important commands for managing groups"},{"location":"level101/linux_basics/linux_server_administration/#becoming-a-superuser","text":"Before running the below commands, do make sure that you have set up a password for user \"shivam\" and user \"root\" using the passwd command described in the above section. The su command can be used to switch users in Linux. Let's now try to switch to user \"shivam\". Let's now try to open the \"/etc/shadow\" file. The operating system didn't allow the user \"shivam\" to read the content of the \"/etc/shadow\" file. This is an important file in Linux which stores the passwords of users. This file can only be accessed by root or users who have the superuser privileges. The sudo command allows a user to run commands with the security privileges of the root user. Do remember that the root user has all the privileges on a system. We can also use su command to switch to the root user and open the above file but doing that will require the password of the root user. An alternative way which is preferred on most modern operating systems is to use sudo command for becoming a superuser. Using this way, a user has to enter his/her password and they need to be a part of the sudo group. How to provide superpriveleges to other users ? Let's first switch to the root user using su command. Do note that using the below command will need you to enter the password for the root user. In case, you forgot to set a password for the root user, type \"exit\" and you will be back as the root user. Now, set up a password using the passwd command. The file /etc/sudoers holds the names of users permitted to invoke sudo . In redhat operating systems, this file is not present by default. We will need to install sudo. We will discuss the yum command in detail in later sections. Try to open the \"/etc/sudoers\" file on the system. The file has a lot of information. This file stores the rules that users must follow when running the sudo command. For example, root is allowed to run any commands from anywhere. One easy way of providing root access to users is to add them to a group which has permissions to run all the commands. \"wheel\" is a group in redhat Linux with such privileges. Let's add the user \"shivam\" to this group so that it also has sudo privileges. Let's now switch back to user \"shivam\" and try to access the \"/etc/shadow\" file. We need to use sudo before running the command since it can only be accessed with the sudo privileges. We have already given sudo privileges to user \u201cshivam\u201d by adding him to the group \u201cwheel\u201d.","title":"Becoming a Superuser"},{"location":"level101/linux_basics/linux_server_administration/#file-permissions","text":"On a Linux operating system, each file and directory is assigned access permissions for the owner of the file, the members of a group of related users and everybody else. This is to make sure that one user is not allowed to access the files and resources of another user. To see the permissions of a file, we can use the ls command. Let's look at the permissions of /etc/passwd file. Let's go over some of the important fields in the output that are related to file permissions.","title":"File Permissions"},{"location":"level101/linux_basics/linux_server_administration/#chmod-command","text":"The chmod command is used to modify files and directories permissions in Linux. The chmod command accepts permissions in as a numerical argument. We can think of permission as a series of bits with 1 representing True or allowed and 0 representing False or not allowed. Permission rwx Binary Decimal Read, write and execute rwx 111 7 Read and write rw- 110 6 Read and execute r-x 101 5 Read only r-- 100 4 Write and execute -wx 011 3 Write only -w- 010 2 Execute only --x 001 1 None --- 000 0 We will now create a new file and check the permission of the file. The group owner doesn't have the permission to write to this file. Let's give the group owner or root the permission to write to it using chmod command. Chmod command can be also used to change the permissions of a directory in the similar way.","title":"Chmod command"},{"location":"level101/linux_basics/linux_server_administration/#chown-command","text":"The chown command is used to change the owner of files or directories in Linux. Command syntax: chown \\ \\ In case, we do not have sudo privileges, we need to use sudo command . Let's switch to user 'shivam' and try changing the owner. We have also changed the owner of the file to root before running the below command. Chown command can also be used to change the owner of a directory in the similar way.","title":"Chown command"},{"location":"level101/linux_basics/linux_server_administration/#chgrp-command","text":"The chgrp command can be used to change the group ownership of files or directories in Linux. The syntax is very similar to that of chown command. Chgrp command can also be used to change the owner of a directory in the similar way.","title":"Chgrp command"},{"location":"level101/linux_basics/linux_server_administration/#ssh-command","text":"The ssh command is used for logging into the remote systems, transfer files between systems and for executing commands on a remote machine. SSH stands for secure shell and is used to provide an encrypted secured connection between two hosts over an insecure network like the internet. Reference: https://www.ssh.com/ssh/command/ We will now discuss passwordless authentication which is secure and most commonly used for ssh authentication.","title":"SSH Command"},{"location":"level101/linux_basics/linux_server_administration/#passwordless-authentication-using-ssh","text":"Using this method, we can ssh into hosts without entering the password. This method is also useful when we want some scripts to perform ssh-related tasks. Passwordless authentication requires the use of a public and private key pair. As the name implies, the public key can be shared with anyone but the private key should be kept private. Lets not get into the details of how this authentication works. You can read more about it here Steps for setting up a passwordless authentication with a remote host: Generating public-private key pair If we already have a key pair stored in \\~/.ssh directory, we will not need to generate keys again. Install openssh package which contains all the commands related to ssh. Generate a key pair using the ssh-keygen command. One can choose the default values for all prompts. After running the ssh-keygen command successfully, we should see two keys present in the \\~/.ssh directory. Id_rsa is the private key and id_rsa.pub is the public key. Do note that the private key can only be read and modified by you. Transferring the public key to the remote host There are multiple ways to transfer the public key to the remote server. We will look at one of the most common ways of doing it using the ssh-copy-id command. Install the openssh-clients package to use ssh-copy-id command. Use the ssh-copy-id command to copy your public key to the remote host. Now, ssh into the remote host using the password authentication. Our public key should be there in \\~/.ssh/authorized_keys now. \\~/.ssh/authorized_key contains a list of public keys. The users associated with these public keys have the ssh access into the remote host.","title":"Passwordless Authentication Using SSH"},{"location":"level101/linux_basics/linux_server_administration/#how-to-run-commands-on-a-remote-host","text":"General syntax: ssh \\@\\ \\","title":"How to run commands on a remote host ?"},{"location":"level101/linux_basics/linux_server_administration/#how-to-transfer-files-from-one-host-to-another-host","text":"General syntax: scp \\ \\","title":"How to transfer files from one host to another host ?"},{"location":"level101/linux_basics/linux_server_administration/#package-management","text":"Package management is the process of installing and managing software on the system. We can install the packages which we require from the Linux package distributor. Different distributors use different packaging systems. Packaging systems Distributions Debian style (.deb) Debian, Ubuntu Red Hat style (.rpm) Fedora, CentOS, Red Hat Enterprise Linux Popular Packaging Systems in Linux Command Description yum install \\ Installs a package on your system yum update \\ Updates a package to it's latest available version yum remove \\ Removes a package from your system yum search \\ Searches for a particular keyword DNF is the successor to YUM which is now used in Fedora for installing and managing packages. DNF may replace YUM in the future on all RPM based Linux distributions. We did find an exact match for the keyword httpd when we searched using yum search command. Let's now install the httpd package. After httpd is installed, we will use the yum remove command to remove httpd package.","title":"Package Management"},{"location":"level101/linux_basics/linux_server_administration/#process-management","text":"In this section, we will study about some useful commands that can be used to monitor the processes on Linux systems.","title":"Process Management"},{"location":"level101/linux_basics/linux_server_administration/#ps-process-status","text":"The ps command is used to know the information of a process or list of processes. If you get an error \"ps command not found\" while running ps command, do install procps package. ps without any arguments is not very useful. Let's try to list all the processes on the system by using the below command. Reference: https://unix.stackexchange.com/questions/106847/what-does-aux-mean-in-ps-aux We can use an additional argument with ps command to list the information about the process with a specific process ID. We can use grep in combination with ps command to list only specific processes.","title":"ps (process status)"},{"location":"level101/linux_basics/linux_server_administration/#top","text":"The top command is used to show information about Linux processes running on the system in real time. It also shows a summary of the system information. For each process, top lists down the process ID, owner, priority, state, cpu utilization, memory utilization and much more information. It also lists down the memory utilization and cpu utilization of the system as a whole along with system uptime and cpu load average.","title":"top"},{"location":"level101/linux_basics/linux_server_administration/#memory-management","text":"In this section, we will study about some useful commands that can be used to view information about the system memory.","title":"Memory Management"},{"location":"level101/linux_basics/linux_server_administration/#free","text":"The free command is used to display the memory usage of the system. The command displays the total free and used space available in the RAM along with space occupied by the caches/buffers. free command by default shows the memory usage in kilobytes. We can use an additional argument to get the data in human-readable format.","title":"free"},{"location":"level101/linux_basics/linux_server_administration/#vmstat","text":"The vmstat command can be used to display the memory usage along with additional information about io and cpu usage.","title":"vmstat"},{"location":"level101/linux_basics/linux_server_administration/#checking-disk-space","text":"In this section, we will study about some useful commands that can be used to view disk space on Linux.","title":"Checking Disk Space"},{"location":"level101/linux_basics/linux_server_administration/#df-disk-free","text":"The df command is used to display the free and available space for each mounted file system.","title":"df (disk free)"},{"location":"level101/linux_basics/linux_server_administration/#du-disk-usage","text":"The du command is used to display disk usage of files and directories on the system. The below command can be used to display the top 5 largest directories in the root directory.","title":"du (disk usage)"},{"location":"level101/linux_basics/linux_server_administration/#daemons","text":"A computer program that runs as a background process is called a daemon. Traditionally, the name of daemon processes ended with d - sshd, httpd etc. We cannot interact with a daemon process as they run in the background. Services and daemons are used interchangeably most of the time.","title":"Daemons"},{"location":"level101/linux_basics/linux_server_administration/#systemd","text":"Systemd is a system and service manager for Linux operating systems. Systemd units are the building blocks of systemd. These units are represented by unit configuration files. The below examples shows the unit configuration files available at /usr/lib/systemd/system which are distributed by installed RPM packages. We are more interested in the configuration file that ends with service as these are service units.","title":"Systemd"},{"location":"level101/linux_basics/linux_server_administration/#managing-system-services","text":"Service units end with .service file extension. Systemctl command can be used to start/stop/restart the services managed by systemd. Command Description systemctl start name.service Starts a service systemctl stop name.service Stops a service systemctl restart name.service Restarts a service systemctl status name.service Check the status of a service systemctl reload name.service Reload the configuration of a service","title":"Managing System Services"},{"location":"level101/linux_basics/linux_server_administration/#logs","text":"In this section, we will talk about some important files and directories which can be very useful for viewing system logs and applications logs in Linux. These logs can be very useful when you are troubleshooting on the system.","title":"Logs"},{"location":"level101/linux_networking/conclusion/","text":"Conclusion With this we have traversed through the TCP/IP stack completely. We hope there will be a different perspective when one opens any website in the browser post the course. During the course we have also dissected what are common tasks in this pipeline which falls under the ambit of SRE. Post Training Exercises Setup own DNS resolver in the dev environment which acts as an authoritative DNS server for example.com and forwarder for other domains. Update resolv.conf to use the new DNS resolver running in localhost Set up a site dummy.example.com in localhost and run a webserver with a self signed certificate. Update the trusted CAs or pass self signed CA\u2019s public key as a parameter so that curl https://dummy.example.com -v works properly without self signed cert warning Update the routing table to use another host(container/VM) in the same network as a gateway for 8.8.8.8/32 and run ping 8.8.8.8. Do the packet capture on the new gateway to see L3 hop is working as expected(might need to disable icmp_redirect)","title":"Conclusion"},{"location":"level101/linux_networking/conclusion/#conclusion","text":"With this we have traversed through the TCP/IP stack completely. We hope there will be a different perspective when one opens any website in the browser post the course. During the course we have also dissected what are common tasks in this pipeline which falls under the ambit of SRE.","title":"Conclusion"},{"location":"level101/linux_networking/conclusion/#post-training-exercises","text":"Setup own DNS resolver in the dev environment which acts as an authoritative DNS server for example.com and forwarder for other domains. Update resolv.conf to use the new DNS resolver running in localhost Set up a site dummy.example.com in localhost and run a webserver with a self signed certificate. Update the trusted CAs or pass self signed CA\u2019s public key as a parameter so that curl https://dummy.example.com -v works properly without self signed cert warning Update the routing table to use another host(container/VM) in the same network as a gateway for 8.8.8.8/32 and run ping 8.8.8.8. Do the packet capture on the new gateway to see L3 hop is working as expected(might need to disable icmp_redirect)","title":"Post Training Exercises"},{"location":"level101/linux_networking/dns/","text":"DNS Domain Names are the simple human-readable names for websites. The Internet understands only IP addresses, but since memorizing incoherent numbers is not practical, domain names are used instead. These domain names are translated into IP addresses by the DNS infrastructure. When somebody tries to open www.linkedin.com in the browser, the browser tries to convert www.linkedin.com to an IP Address. This process is called DNS resolution. A simple pseudocode depicting this process looks this ip, err = getIPAddress(domainName) if err: print(\u201cunknown Host Exception while trying to resolve:%s\u201d.format(domainName)) Now let\u2019s try to understand what happens inside the getIPAddress function. The browser would have a DNS cache of its own where it checks if there is a mapping for the domainName to an IP Address already available, in which case the browser uses that IP address. If no such mapping exists, the browser calls gethostbyname syscall to ask the operating system to find the IP address for the given domainName def getIPAddress(domainName): resp, fail = lookupCache(domainName) If not fail: return resp else: resp, err = gethostbyname(domainName) if err: return null, err else: return resp Now lets understand what operating system kernel does when the gethostbyname function is called. The Linux operating system looks at the file /etc/nsswitch.conf file which usually has a line hosts: files dns This line means the OS has to look up first in file (/etc/hosts) and then use DNS protocol to do the resolution if there is no match in /etc/hosts. The file /etc/hosts is of format IPAddress FQDN [FQDN].* 127.0.0.1 localhost.localdomain localhost ::1 localhost.localdomain localhost If a match exists for a domain in this file then that IP address is returned by the OS. Lets add a line to this file 127.0.0.1 test.linkedin.com And then do ping test.linkedin.com ping test.linkedin.com -n PING test.linkedin.com (127.0.0.1) 56(84) bytes of data. 64 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.047 ms 64 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.036 ms 64 bytes from 127.0.0.1: icmp_seq=3 ttl=64 time=0.037 ms As mentioned earlier, if no match exists in /etc/hosts, the OS tries to do a DNS resolution using the DNS protocol. The linux system makes a DNS request to the first IP in /etc/resolv.conf. If there is no response, requests are sent to subsequent servers in resolv.conf. These servers in resolv.conf are called DNS resolvers. The DNS resolvers are populated by DHCP or statically configured by an administrator. Dig is a userspace DNS system which creates and sends request to DNS resolvers and prints the response it receives to the console. #run this command in one shell to capture all DNS requests sudo tcpdump -s 0 -A -i any port 53 #make a dig request from another shell dig linkedin.com 13:19:54.432507 IP 172.19.209.122.56497 > 172.23.195.101.53: 527+ [1au] A? linkedin.com. (41) ....E..E....@.n....z...e...5.1.:... .........linkedin.com.......)........ 13:19:54.485131 IP 172.23.195.101.53 > 172.19.209.122.56497: 527 1/0/1 A 108.174.10.10 (57) ....E..U..@.|. ....e...z.5...A...............linkedin.com..............3..l. ..)........ The packet capture shows a request is made to 172.23.195.101:53 (this is the resolver in /etc/resolv.conf) for linkedin.com and a response is received from 172.23.195.101 with the IP address of linkedin.com 108.174.10.10 Now let's try to understand how DNS resolver tries to find the IP address of linkedin.com. DNS resolver first looks at its cache. Since many devices in the network can query for the domain name linkedin.com, the name resolution result may already exist in the cache. If there is a cache miss, it starts the DNS resolution process. The DNS server breaks \u201clinkedin.com\u201d to \u201c.\u201d, \u201ccom.\u201d and \u201clinkedin.com.\u201d and starts DNS resolution from \u201c.\u201d. The \u201c.\u201d is called root domain and those IPs are known to the DNS resolver software. DNS resolver queries the root domain Nameservers to find the right nameservers which could respond regarding details for \"com.\". The address of the authoritative nameserver of \u201ccom.\u201d is returned. Now the DNS resolution service contacts the authoritative nameserver for \u201ccom.\u201d to fetch the authoritative nameserver for \u201clinkedin.com\u201d. Once an authoritative nameserver of \u201clinkedin.com\u201d is known, the resolver contacts Linkedin\u2019s nameserver to provide the IP address of \u201clinkedin.com\u201d. This whole process can be visualized by running dig +trace linkedin.com linkedin.com. 3600 IN A 108.174.10.10 This DNS response has 5 fields where the first field is the request and the last field is the response. The second field is the Time to Live which says how long the DNS response is valid in seconds. In this case this mapping of linkedin.com is valid for 1 hour. This is how the resolvers and application(browser) maintain their cache. Any request for linkedin.com beyond 1 hour will be treated as a cache miss as the mapping has expired its TTL and the whole process has to be redone. The 4th field says the type of DNS response/request. Some of the various DNS query types are A, AAAA, NS, TXT, PTR, MX and CNAME. - A record returns IPV4 address of the domain name - AAAA record returns the IPV6 address of the domain Name - NS record returns the authoritative nameserver for the domain name - CNAME records are aliases to the domain names. Some domains point to other domain names and resolving the latter domain name gives an IP which is used as an IP for the former domain name as well. Example www.linkedin.com\u2019s IP address is the same as 2-01-2c3e-005a.cdx.cedexis.net. - For the brevity we are not discussing other DNS record types, the RFC of each of these records are available here . dig A linkedin.com +short 108.174.10.10 dig AAAA linkedin.com +short 2620:109:c002::6cae:a0a dig NS linkedin.com +short dns3.p09.nsone.net. dns4.p09.nsone.net. dns2.p09.nsone.net. ns4.p43.dynect.net. ns1.p43.dynect.net. ns2.p43.dynect.net. ns3.p43.dynect.net. dns1.p09.nsone.net. dig www.linkedin.com CNAME +short 2-01-2c3e-005a.cdx.cedexis.net. Armed with these fundamentals of DNS lets see usecases where DNS is used by SREs. Applications in SRE role This section covers some of the common solutions SRE can derive from DNS Every company has to have its internal DNS infrastructure for intranet sites and internal services like databases and other internal applications like wiki. So there has to be a DNS infrastructure maintained for those domain names by the infrastructure team. This DNS infrastructure has to be optimized and scaled so that it doesn\u2019t become a single point of failure. Failure of the internal DNS infrastructure can cause API calls of microservices to fail and other cascading effects. DNS can also be used for discovering services. For example the hostname serviceb.internal.example.com could list instances which run service b internally in example.com company. Cloud providers provide options to enable DNS discovery( example ) DNS is used by cloud providers and CDN providers to scale their services. In Azure/AWS, Load Balancers are given a CNAME instead of IPAddress. They update the IPAddress of the Loadbalancers as they scale by changing the IP Address of alias domain names. This is one of the reasons why A records of such alias domains are short lived like 1 minute. DNS can also be used to make clients get IP addresses closer to their location so that their HTTP calls can be responded faster if the company has a presence geographically distributed. SRE also has to understand since there is no verification in DNS infrastructure, these responses can be spoofed. This is safeguarded by other protocols like HTTPS(dealt later). DNSSEC protects from forged or manipulated DNS responses. Stale DNS cache can be a problem. Some apps might still be using expired DNS records for their api calls. This is something SRE has to be wary of when doing maintenance. DNS Loadbalancing and service discovery also has to understand TTL and the servers can be removed from the pool only after waiting till TTL post the changes are made to DNS records. If this is not done, a certain portion of the traffic will fail as the server is removed before the TTL.","title":"DNS"},{"location":"level101/linux_networking/dns/#dns","text":"Domain Names are the simple human-readable names for websites. The Internet understands only IP addresses, but since memorizing incoherent numbers is not practical, domain names are used instead. These domain names are translated into IP addresses by the DNS infrastructure. When somebody tries to open www.linkedin.com in the browser, the browser tries to convert www.linkedin.com to an IP Address. This process is called DNS resolution. A simple pseudocode depicting this process looks this ip, err = getIPAddress(domainName) if err: print(\u201cunknown Host Exception while trying to resolve:%s\u201d.format(domainName)) Now let\u2019s try to understand what happens inside the getIPAddress function. The browser would have a DNS cache of its own where it checks if there is a mapping for the domainName to an IP Address already available, in which case the browser uses that IP address. If no such mapping exists, the browser calls gethostbyname syscall to ask the operating system to find the IP address for the given domainName def getIPAddress(domainName): resp, fail = lookupCache(domainName) If not fail: return resp else: resp, err = gethostbyname(domainName) if err: return null, err else: return resp Now lets understand what operating system kernel does when the gethostbyname function is called. The Linux operating system looks at the file /etc/nsswitch.conf file which usually has a line hosts: files dns This line means the OS has to look up first in file (/etc/hosts) and then use DNS protocol to do the resolution if there is no match in /etc/hosts. The file /etc/hosts is of format IPAddress FQDN [FQDN].* 127.0.0.1 localhost.localdomain localhost ::1 localhost.localdomain localhost If a match exists for a domain in this file then that IP address is returned by the OS. Lets add a line to this file 127.0.0.1 test.linkedin.com And then do ping test.linkedin.com ping test.linkedin.com -n PING test.linkedin.com (127.0.0.1) 56(84) bytes of data. 64 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.047 ms 64 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.036 ms 64 bytes from 127.0.0.1: icmp_seq=3 ttl=64 time=0.037 ms As mentioned earlier, if no match exists in /etc/hosts, the OS tries to do a DNS resolution using the DNS protocol. The linux system makes a DNS request to the first IP in /etc/resolv.conf. If there is no response, requests are sent to subsequent servers in resolv.conf. These servers in resolv.conf are called DNS resolvers. The DNS resolvers are populated by DHCP or statically configured by an administrator. Dig is a userspace DNS system which creates and sends request to DNS resolvers and prints the response it receives to the console. #run this command in one shell to capture all DNS requests sudo tcpdump -s 0 -A -i any port 53 #make a dig request from another shell dig linkedin.com 13:19:54.432507 IP 172.19.209.122.56497 > 172.23.195.101.53: 527+ [1au] A? linkedin.com. (41) ....E..E....@.n....z...e...5.1.:... .........linkedin.com.......)........ 13:19:54.485131 IP 172.23.195.101.53 > 172.19.209.122.56497: 527 1/0/1 A 108.174.10.10 (57) ....E..U..@.|. ....e...z.5...A...............linkedin.com..............3..l. ..)........ The packet capture shows a request is made to 172.23.195.101:53 (this is the resolver in /etc/resolv.conf) for linkedin.com and a response is received from 172.23.195.101 with the IP address of linkedin.com 108.174.10.10 Now let's try to understand how DNS resolver tries to find the IP address of linkedin.com. DNS resolver first looks at its cache. Since many devices in the network can query for the domain name linkedin.com, the name resolution result may already exist in the cache. If there is a cache miss, it starts the DNS resolution process. The DNS server breaks \u201clinkedin.com\u201d to \u201c.\u201d, \u201ccom.\u201d and \u201clinkedin.com.\u201d and starts DNS resolution from \u201c.\u201d. The \u201c.\u201d is called root domain and those IPs are known to the DNS resolver software. DNS resolver queries the root domain Nameservers to find the right nameservers which could respond regarding details for \"com.\". The address of the authoritative nameserver of \u201ccom.\u201d is returned. Now the DNS resolution service contacts the authoritative nameserver for \u201ccom.\u201d to fetch the authoritative nameserver for \u201clinkedin.com\u201d. Once an authoritative nameserver of \u201clinkedin.com\u201d is known, the resolver contacts Linkedin\u2019s nameserver to provide the IP address of \u201clinkedin.com\u201d. This whole process can be visualized by running dig +trace linkedin.com linkedin.com. 3600 IN A 108.174.10.10 This DNS response has 5 fields where the first field is the request and the last field is the response. The second field is the Time to Live which says how long the DNS response is valid in seconds. In this case this mapping of linkedin.com is valid for 1 hour. This is how the resolvers and application(browser) maintain their cache. Any request for linkedin.com beyond 1 hour will be treated as a cache miss as the mapping has expired its TTL and the whole process has to be redone. The 4th field says the type of DNS response/request. Some of the various DNS query types are A, AAAA, NS, TXT, PTR, MX and CNAME. - A record returns IPV4 address of the domain name - AAAA record returns the IPV6 address of the domain Name - NS record returns the authoritative nameserver for the domain name - CNAME records are aliases to the domain names. Some domains point to other domain names and resolving the latter domain name gives an IP which is used as an IP for the former domain name as well. Example www.linkedin.com\u2019s IP address is the same as 2-01-2c3e-005a.cdx.cedexis.net. - For the brevity we are not discussing other DNS record types, the RFC of each of these records are available here . dig A linkedin.com +short 108.174.10.10 dig AAAA linkedin.com +short 2620:109:c002::6cae:a0a dig NS linkedin.com +short dns3.p09.nsone.net. dns4.p09.nsone.net. dns2.p09.nsone.net. ns4.p43.dynect.net. ns1.p43.dynect.net. ns2.p43.dynect.net. ns3.p43.dynect.net. dns1.p09.nsone.net. dig www.linkedin.com CNAME +short 2-01-2c3e-005a.cdx.cedexis.net. Armed with these fundamentals of DNS lets see usecases where DNS is used by SREs.","title":"DNS"},{"location":"level101/linux_networking/dns/#applications-in-sre-role","text":"This section covers some of the common solutions SRE can derive from DNS Every company has to have its internal DNS infrastructure for intranet sites and internal services like databases and other internal applications like wiki. So there has to be a DNS infrastructure maintained for those domain names by the infrastructure team. This DNS infrastructure has to be optimized and scaled so that it doesn\u2019t become a single point of failure. Failure of the internal DNS infrastructure can cause API calls of microservices to fail and other cascading effects. DNS can also be used for discovering services. For example the hostname serviceb.internal.example.com could list instances which run service b internally in example.com company. Cloud providers provide options to enable DNS discovery( example ) DNS is used by cloud providers and CDN providers to scale their services. In Azure/AWS, Load Balancers are given a CNAME instead of IPAddress. They update the IPAddress of the Loadbalancers as they scale by changing the IP Address of alias domain names. This is one of the reasons why A records of such alias domains are short lived like 1 minute. DNS can also be used to make clients get IP addresses closer to their location so that their HTTP calls can be responded faster if the company has a presence geographically distributed. SRE also has to understand since there is no verification in DNS infrastructure, these responses can be spoofed. This is safeguarded by other protocols like HTTPS(dealt later). DNSSEC protects from forged or manipulated DNS responses. Stale DNS cache can be a problem. Some apps might still be using expired DNS records for their api calls. This is something SRE has to be wary of when doing maintenance. DNS Loadbalancing and service discovery also has to understand TTL and the servers can be removed from the pool only after waiting till TTL post the changes are made to DNS records. If this is not done, a certain portion of the traffic will fail as the server is removed before the TTL.","title":"Applications in SRE role"},{"location":"level101/linux_networking/http/","text":"HTTP Till this point we have only got the IP address of linkedin.com. The HTML page of linkedin.com is served by HTTP protocol which the browser renders. Browser sends a HTTP request to the IP of the server determined above. Request has a verb GET, PUT, POST followed by a path and query parameters and lines of key value pair which gives information about the client and capabilities of the client like contents it can accept and a body (usually in POST or PUT) # Eg run the following in your container and have a look at the headers curl linkedin.com -v * Connected to linkedin.com (108.174.10.10) port 80 (#0) > GET / HTTP/1.1 > Host: linkedin.com > User-Agent: curl/7.64.1 > Accept: */* > < HTTP/1.1 301 Moved Permanently < Date: Mon, 09 Nov 2020 10:39:43 GMT < X-Li-Pop: prod-esv5 < X-LI-Proto: http/1.1 < Location: https://www.linkedin.com/ < Content-Length: 0 < * Connection #0 to host linkedin.com left intact * Closing connection 0 Here, in the first line GET is the verb, / is the path and 1.1 is the HTTP protocol version. Then there are key value pairs which give client capabilities and some details to the server. The server responds back with HTTP version, Status Code and Status message . Status codes 2xx means success, 3xx denotes redirection, 4xx denotes client side errors and 5xx server side errors. We will now jump in to see the difference between HTTP/1.0 and HTTP/1.1. #On the terminal type telnet www.linkedin.com 80 #Copy and paste the following with an empty new line at last in the telnet STDIN GET / HTTP/1.1 HOST:linkedin.com USER-AGENT: curl This would get server response and waits for next input as the underlying connection to www.linkedin.com can be reused for further queries. While going through TCP, we can understand the benefits of this. But in HTTP/1.0 this connection will be immediately closed after the response meaning new connection has to be opened for each query. HTTP/1.1 can have only one inflight request in an open connection but connection can be reused for multiple requests one after another. One of the benefits of HTTP/2.0 over HTTP/1.1 is we can have multiple inflight requests on the same connection. We are restricting our scope to generic HTTP and not jumping to the intricacies of each protocol version but they should be straight forward to understand post the course. HTTP is called stateless protocol . This section we will try to understand what stateless means. Say we logged in to linkedin.com, each request to linkedin.com from the client will have no context of the user and it makes no sense to prompt user to login for each page/resource. This problem of HTTP is solved by COOKIE . A user is created a session when a user logs in. This session identifier is sent to the browser via SET-COOKIE header. The browser stores the COOKIE till the expiry set by the server and sends the cookie for each request from hereon for linkedin.com. More details on cookies are available here . Cookies are a critical piece of information like password and since HTTP is a plain text protocol, any man in the middle can capture either password or cookies and can breach the privacy of the user. Similarly as discussed during DNS a spoofed IP of linkedin.com can cause a phishing attack on users where an user can give linkedin\u2019s password to login on the malicious site. To solve both problems HTTPs came in place and HTTPs has to be mandated. HTTPS has to provide server identification and encryption of data between client and server. The server administrator has to generate a private public key pair and certificate request. This certificate request has to be signed by a certificate authority which converts the certificate request to a certificate. The server administrator has to update the certificate and private key to the webserver. The certificate has details about the server (like domain name for which it serves, expiry date), public key of the server. The private key is a secret to the server and losing the private key loses the trust the server provides. When clients connect, the client sends a HELLO. The server sends its certificate to the client. The client checks the validity of the cert by seeing if it is within its expiry time, if it is signed by a trusted authority and the hostname in the cert is the same as the server. This validation makes sure the server is the right server and there is no phishing. Once that is validated, the client negotiates a symmetrical key and cipher with the server by encrypting the negotiation with the public key of the server. Nobody else other than the server who has the private key can understand this data. Once negotiation is complete, that symmetric key and algorithm is used for further encryption which can be decrypted only by client and server from thereon as they only know the symmetric key and algorithm. The switch to symmetric algorithm from asymmetric encryption algorithm is to not strain the resources of client devices as symmetric encryption is generally less resource intensive than asymmetric. #Try the following on your terminal to see the cert details like Subject Name(domain name), Issuer details, Expiry date curl https://www.linkedin.com -v * Connected to www.linkedin.com (13.107.42.14) port 443 (#0) * ALPN, offering h2 * ALPN, offering http/1.1 * successfully set certificate verify locations: * CAfile: /etc/ssl/cert.pem CApath: none * TLSv1.2 (OUT), TLS handshake, Client hello (1): } [230 bytes data] * TLSv1.2 (IN), TLS handshake, Server hello (2): { [90 bytes data] * TLSv1.2 (IN), TLS handshake, Certificate (11): { [3171 bytes data] * TLSv1.2 (IN), TLS handshake, Server key exchange (12): { [365 bytes data] * TLSv1.2 (IN), TLS handshake, Server finished (14): { [4 bytes data] * TLSv1.2 (OUT), TLS handshake, Client key exchange (16): } [102 bytes data] * TLSv1.2 (OUT), TLS change cipher, Change cipher spec (1): } [1 bytes data] * TLSv1.2 (OUT), TLS handshake, Finished (20): } [16 bytes data] * TLSv1.2 (IN), TLS change cipher, Change cipher spec (1): { [1 bytes data] * TLSv1.2 (IN), TLS handshake, Finished (20): { [16 bytes data] * SSL connection using TLSv1.2 / ECDHE-RSA-AES256-GCM-SHA384 * ALPN, server accepted to use h2 * Server certificate: * subject: C=US; ST=California; L=Sunnyvale; O=LinkedIn Corporation; CN=www.linkedin.com * start date: Oct 2 00:00:00 2020 GMT * expire date: Apr 2 12:00:00 2021 GMT * subjectAltName: host \"www.linkedin.com\" matched cert's \"www.linkedin.com\" * issuer: C=US; O=DigiCert Inc; CN=DigiCert SHA2 Secure Server CA * SSL certificate verify ok. * Using HTTP2, server supports multi-use * Connection state changed (HTTP/2 confirmed) * Copying HTTP/2 data in stream buffer to connection buffer after upgrade: len=0 * Using Stream ID: 1 (easy handle 0x7fb055808200) * Connection state changed (MAX_CONCURRENT_STREAMS == 100)! 0 82117 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0 * Connection #0 to host www.linkedin.com left intact HTTP/2 200 cache-control: no-cache, no-store pragma: no-cache content-length: 82117 content-type: text/html; charset=utf-8 expires: Thu, 01 Jan 1970 00:00:00 GMT set-cookie: JSESSIONID=ajax:2747059799136291014; SameSite=None; Path=/; Domain=.www.linkedin.com; Secure set-cookie: lang=v=2&lang=en-us; SameSite=None; Path=/; Domain=linkedin.com; Secure set-cookie: bcookie=\"v=2&70bd59e3-5a51-406c-8e0d-dd70befa8890\"; domain=.linkedin.com; Path=/; Secure; Expires=Wed, 09-Nov-2022 22:27:42 GMT; SameSite=None set-cookie: bscookie=\"v=1&202011091050107ae9b7ac-fe97-40fc-830d-d7a9ccf80659AQGib5iXwarbY8CCBP94Q39THkgUlx6J\"; domain=.www.linkedin.com; Path=/; Secure; Expires=Wed, 09-Nov-2022 22:27:42 GMT; HttpOnly; SameSite=None set-cookie: lissc=1; domain=.linkedin.com; Path=/; Secure; Expires=Tue, 09-Nov-2021 10:50:10 GMT; SameSite=None set-cookie: lidc=\"b=VGST04:s=V:r=V:g=2201:u=1:i=1604919010:t=1605005410:v=1:sig=AQHe-KzU8i_5Iy6MwnFEsgRct3c9Lh5R\"; Expires=Tue, 10 Nov 2020 10:50:10 GMT; domain=.linkedin.com; Path=/; SameSite=None; Secure x-fs-txn-id: 2b8d5409ba70 x-fs-uuid: 61bbf94956d14516302567fc882b0000 expect-ct: max-age=86400, report-uri=\"https://www.linkedin.com/platform-telemetry/ct\" x-xss-protection: 1; mode=block content-security-policy-report-only: default-src 'none'; connect-src 'self' www.linkedin.com www.google-analytics.com https://dpm.demdex.net/id lnkd.demdex.net blob: https://linkedin.sc.omtrdc.net/b/ss/ static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; script-src 'sha256-THuVhwbXPeTR0HszASqMOnIyxqEgvGyBwSPBKBF/iMc=' 'sha256-PyCXNcEkzRWqbiNr087fizmiBBrq9O6GGD8eV3P09Ik=' 'sha256-2SQ55Erm3CPCb+k03EpNxU9bdV3XL9TnVTriDs7INZ4=' 'sha256-S/KSPe186K/1B0JEjbIXcCdpB97krdzX05S+dHnQjUs=' platform.linkedin.com platform-akam.linkedin.com platform-ecst.linkedin.com platform-azur.linkedin.com static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; img-src data: blob: *; font-src data: *; style-src 'self' 'unsafe-inline' static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; media-src dms.licdn.com; child-src blob: *; frame-src 'self' lnkd.demdex.net linkedin.cdn.qualaroo.com; manifest-src 'self'; report-uri https://www.linkedin.com/platform-telemetry/csp?f=g content-security-policy: default-src *; connect-src 'self' https://media-src.linkedin.com/media/ www.linkedin.com s.c.lnkd.licdn.com m.c.lnkd.licdn.com s.c.exp1.licdn.com s.c.exp2.licdn.com m.c.exp1.licdn.com m.c.exp2.licdn.com wss://*.linkedin.com dms.licdn.com https://dpm.demdex.net/id lnkd.demdex.net blob: https://accounts.google.com/gsi/status https://linkedin.sc.omtrdc.net/b/ss/ www.google-analytics.com static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com media.licdn.com media-exp1.licdn.com media-exp2.licdn.com media-exp3.licdn.com; img-src data: blob: *; font-src data: *; style-src 'unsafe-inline' 'self' static-src.linkedin.com *.licdn.com; script-src 'report-sample' 'unsafe-inline' 'unsafe-eval' 'self' spdy.linkedin.com static-src.linkedin.com *.ads.linkedin.com *.licdn.com static.chartbeat.com www.google-analytics.com ssl.google-analytics.com bcvipva02.rightnowtech.com www.bizographics.com sjs.bizographics.com js.bizographics.com d.la4-c1-was.salesforceliveagent.com slideshare.www.linkedin.com https://snap.licdn.com/li.lms-analytics/ platform.linkedin.com platform-akam.linkedin.com platform-ecst.linkedin.com platform-azur.linkedin.com; object-src 'none'; media-src blob: *; child-src blob: lnkd-communities: voyager: *; frame-ancestors 'self'; report-uri https://www.linkedin.com/platform-telemetry/csp?f=l x-frame-options: sameorigin x-content-type-options: nosniff strict-transport-security: max-age=2592000 x-li-fabric: prod-lva1 x-li-pop: afd-prod-lva1 x-li-proto: http/2 x-li-uuid: Ybv5SVbRRRYwJWf8iCsAAA== x-msedge-ref: Ref A: CFB9AC1D2B0645DDB161CEE4A4909AEF Ref B: BOM02EDGE0712 Ref C: 2020-11-09T10:50:10Z date: Mon, 09 Nov 2020 10:50:10 GMT * Closing connection 0 Here my system has a list of certificate authorities it trusts in this file /etc/ssl/cert.pem. Curl validates the certificate is for www.linkedin.com by seeing the CN section of the subject part of the certificate. It also makes sure the certificate is not expired by seeing the expire date. It also validates the signature on the certificate by using the public key of issuer Digicert in /etc/ssl/cert.pem. Once this is done, using the public key of www.linkedin.com it negotiates cipher TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 with a symmetric key. Subsequent data transfer including first HTTP request uses the same cipher and symmetric key.","title":"HTTP"},{"location":"level101/linux_networking/http/#http","text":"Till this point we have only got the IP address of linkedin.com. The HTML page of linkedin.com is served by HTTP protocol which the browser renders. Browser sends a HTTP request to the IP of the server determined above. Request has a verb GET, PUT, POST followed by a path and query parameters and lines of key value pair which gives information about the client and capabilities of the client like contents it can accept and a body (usually in POST or PUT) # Eg run the following in your container and have a look at the headers curl linkedin.com -v * Connected to linkedin.com (108.174.10.10) port 80 (#0) > GET / HTTP/1.1 > Host: linkedin.com > User-Agent: curl/7.64.1 > Accept: */* > < HTTP/1.1 301 Moved Permanently < Date: Mon, 09 Nov 2020 10:39:43 GMT < X-Li-Pop: prod-esv5 < X-LI-Proto: http/1.1 < Location: https://www.linkedin.com/ < Content-Length: 0 < * Connection #0 to host linkedin.com left intact * Closing connection 0 Here, in the first line GET is the verb, / is the path and 1.1 is the HTTP protocol version. Then there are key value pairs which give client capabilities and some details to the server. The server responds back with HTTP version, Status Code and Status message . Status codes 2xx means success, 3xx denotes redirection, 4xx denotes client side errors and 5xx server side errors. We will now jump in to see the difference between HTTP/1.0 and HTTP/1.1. #On the terminal type telnet www.linkedin.com 80 #Copy and paste the following with an empty new line at last in the telnet STDIN GET / HTTP/1.1 HOST:linkedin.com USER-AGENT: curl This would get server response and waits for next input as the underlying connection to www.linkedin.com can be reused for further queries. While going through TCP, we can understand the benefits of this. But in HTTP/1.0 this connection will be immediately closed after the response meaning new connection has to be opened for each query. HTTP/1.1 can have only one inflight request in an open connection but connection can be reused for multiple requests one after another. One of the benefits of HTTP/2.0 over HTTP/1.1 is we can have multiple inflight requests on the same connection. We are restricting our scope to generic HTTP and not jumping to the intricacies of each protocol version but they should be straight forward to understand post the course. HTTP is called stateless protocol . This section we will try to understand what stateless means. Say we logged in to linkedin.com, each request to linkedin.com from the client will have no context of the user and it makes no sense to prompt user to login for each page/resource. This problem of HTTP is solved by COOKIE . A user is created a session when a user logs in. This session identifier is sent to the browser via SET-COOKIE header. The browser stores the COOKIE till the expiry set by the server and sends the cookie for each request from hereon for linkedin.com. More details on cookies are available here . Cookies are a critical piece of information like password and since HTTP is a plain text protocol, any man in the middle can capture either password or cookies and can breach the privacy of the user. Similarly as discussed during DNS a spoofed IP of linkedin.com can cause a phishing attack on users where an user can give linkedin\u2019s password to login on the malicious site. To solve both problems HTTPs came in place and HTTPs has to be mandated. HTTPS has to provide server identification and encryption of data between client and server. The server administrator has to generate a private public key pair and certificate request. This certificate request has to be signed by a certificate authority which converts the certificate request to a certificate. The server administrator has to update the certificate and private key to the webserver. The certificate has details about the server (like domain name for which it serves, expiry date), public key of the server. The private key is a secret to the server and losing the private key loses the trust the server provides. When clients connect, the client sends a HELLO. The server sends its certificate to the client. The client checks the validity of the cert by seeing if it is within its expiry time, if it is signed by a trusted authority and the hostname in the cert is the same as the server. This validation makes sure the server is the right server and there is no phishing. Once that is validated, the client negotiates a symmetrical key and cipher with the server by encrypting the negotiation with the public key of the server. Nobody else other than the server who has the private key can understand this data. Once negotiation is complete, that symmetric key and algorithm is used for further encryption which can be decrypted only by client and server from thereon as they only know the symmetric key and algorithm. The switch to symmetric algorithm from asymmetric encryption algorithm is to not strain the resources of client devices as symmetric encryption is generally less resource intensive than asymmetric. #Try the following on your terminal to see the cert details like Subject Name(domain name), Issuer details, Expiry date curl https://www.linkedin.com -v * Connected to www.linkedin.com (13.107.42.14) port 443 (#0) * ALPN, offering h2 * ALPN, offering http/1.1 * successfully set certificate verify locations: * CAfile: /etc/ssl/cert.pem CApath: none * TLSv1.2 (OUT), TLS handshake, Client hello (1): } [230 bytes data] * TLSv1.2 (IN), TLS handshake, Server hello (2): { [90 bytes data] * TLSv1.2 (IN), TLS handshake, Certificate (11): { [3171 bytes data] * TLSv1.2 (IN), TLS handshake, Server key exchange (12): { [365 bytes data] * TLSv1.2 (IN), TLS handshake, Server finished (14): { [4 bytes data] * TLSv1.2 (OUT), TLS handshake, Client key exchange (16): } [102 bytes data] * TLSv1.2 (OUT), TLS change cipher, Change cipher spec (1): } [1 bytes data] * TLSv1.2 (OUT), TLS handshake, Finished (20): } [16 bytes data] * TLSv1.2 (IN), TLS change cipher, Change cipher spec (1): { [1 bytes data] * TLSv1.2 (IN), TLS handshake, Finished (20): { [16 bytes data] * SSL connection using TLSv1.2 / ECDHE-RSA-AES256-GCM-SHA384 * ALPN, server accepted to use h2 * Server certificate: * subject: C=US; ST=California; L=Sunnyvale; O=LinkedIn Corporation; CN=www.linkedin.com * start date: Oct 2 00:00:00 2020 GMT * expire date: Apr 2 12:00:00 2021 GMT * subjectAltName: host \"www.linkedin.com\" matched cert's \"www.linkedin.com\" * issuer: C=US; O=DigiCert Inc; CN=DigiCert SHA2 Secure Server CA * SSL certificate verify ok. * Using HTTP2, server supports multi-use * Connection state changed (HTTP/2 confirmed) * Copying HTTP/2 data in stream buffer to connection buffer after upgrade: len=0 * Using Stream ID: 1 (easy handle 0x7fb055808200) * Connection state changed (MAX_CONCURRENT_STREAMS == 100)! 0 82117 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0 * Connection #0 to host www.linkedin.com left intact HTTP/2 200 cache-control: no-cache, no-store pragma: no-cache content-length: 82117 content-type: text/html; charset=utf-8 expires: Thu, 01 Jan 1970 00:00:00 GMT set-cookie: JSESSIONID=ajax:2747059799136291014; SameSite=None; Path=/; Domain=.www.linkedin.com; Secure set-cookie: lang=v=2&lang=en-us; SameSite=None; Path=/; Domain=linkedin.com; Secure set-cookie: bcookie=\"v=2&70bd59e3-5a51-406c-8e0d-dd70befa8890\"; domain=.linkedin.com; Path=/; Secure; Expires=Wed, 09-Nov-2022 22:27:42 GMT; SameSite=None set-cookie: bscookie=\"v=1&202011091050107ae9b7ac-fe97-40fc-830d-d7a9ccf80659AQGib5iXwarbY8CCBP94Q39THkgUlx6J\"; domain=.www.linkedin.com; Path=/; Secure; Expires=Wed, 09-Nov-2022 22:27:42 GMT; HttpOnly; SameSite=None set-cookie: lissc=1; domain=.linkedin.com; Path=/; Secure; Expires=Tue, 09-Nov-2021 10:50:10 GMT; SameSite=None set-cookie: lidc=\"b=VGST04:s=V:r=V:g=2201:u=1:i=1604919010:t=1605005410:v=1:sig=AQHe-KzU8i_5Iy6MwnFEsgRct3c9Lh5R\"; Expires=Tue, 10 Nov 2020 10:50:10 GMT; domain=.linkedin.com; Path=/; SameSite=None; Secure x-fs-txn-id: 2b8d5409ba70 x-fs-uuid: 61bbf94956d14516302567fc882b0000 expect-ct: max-age=86400, report-uri=\"https://www.linkedin.com/platform-telemetry/ct\" x-xss-protection: 1; mode=block content-security-policy-report-only: default-src 'none'; connect-src 'self' www.linkedin.com www.google-analytics.com https://dpm.demdex.net/id lnkd.demdex.net blob: https://linkedin.sc.omtrdc.net/b/ss/ static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; script-src 'sha256-THuVhwbXPeTR0HszASqMOnIyxqEgvGyBwSPBKBF/iMc=' 'sha256-PyCXNcEkzRWqbiNr087fizmiBBrq9O6GGD8eV3P09Ik=' 'sha256-2SQ55Erm3CPCb+k03EpNxU9bdV3XL9TnVTriDs7INZ4=' 'sha256-S/KSPe186K/1B0JEjbIXcCdpB97krdzX05S+dHnQjUs=' platform.linkedin.com platform-akam.linkedin.com platform-ecst.linkedin.com platform-azur.linkedin.com static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; img-src data: blob: *; font-src data: *; style-src 'self' 'unsafe-inline' static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com; media-src dms.licdn.com; child-src blob: *; frame-src 'self' lnkd.demdex.net linkedin.cdn.qualaroo.com; manifest-src 'self'; report-uri https://www.linkedin.com/platform-telemetry/csp?f=g content-security-policy: default-src *; connect-src 'self' https://media-src.linkedin.com/media/ www.linkedin.com s.c.lnkd.licdn.com m.c.lnkd.licdn.com s.c.exp1.licdn.com s.c.exp2.licdn.com m.c.exp1.licdn.com m.c.exp2.licdn.com wss://*.linkedin.com dms.licdn.com https://dpm.demdex.net/id lnkd.demdex.net blob: https://accounts.google.com/gsi/status https://linkedin.sc.omtrdc.net/b/ss/ www.google-analytics.com static.licdn.com static-exp1.licdn.com static-exp2.licdn.com static-exp3.licdn.com media.licdn.com media-exp1.licdn.com media-exp2.licdn.com media-exp3.licdn.com; img-src data: blob: *; font-src data: *; style-src 'unsafe-inline' 'self' static-src.linkedin.com *.licdn.com; script-src 'report-sample' 'unsafe-inline' 'unsafe-eval' 'self' spdy.linkedin.com static-src.linkedin.com *.ads.linkedin.com *.licdn.com static.chartbeat.com www.google-analytics.com ssl.google-analytics.com bcvipva02.rightnowtech.com www.bizographics.com sjs.bizographics.com js.bizographics.com d.la4-c1-was.salesforceliveagent.com slideshare.www.linkedin.com https://snap.licdn.com/li.lms-analytics/ platform.linkedin.com platform-akam.linkedin.com platform-ecst.linkedin.com platform-azur.linkedin.com; object-src 'none'; media-src blob: *; child-src blob: lnkd-communities: voyager: *; frame-ancestors 'self'; report-uri https://www.linkedin.com/platform-telemetry/csp?f=l x-frame-options: sameorigin x-content-type-options: nosniff strict-transport-security: max-age=2592000 x-li-fabric: prod-lva1 x-li-pop: afd-prod-lva1 x-li-proto: http/2 x-li-uuid: Ybv5SVbRRRYwJWf8iCsAAA== x-msedge-ref: Ref A: CFB9AC1D2B0645DDB161CEE4A4909AEF Ref B: BOM02EDGE0712 Ref C: 2020-11-09T10:50:10Z date: Mon, 09 Nov 2020 10:50:10 GMT * Closing connection 0 Here my system has a list of certificate authorities it trusts in this file /etc/ssl/cert.pem. Curl validates the certificate is for www.linkedin.com by seeing the CN section of the subject part of the certificate. It also makes sure the certificate is not expired by seeing the expire date. It also validates the signature on the certificate by using the public key of issuer Digicert in /etc/ssl/cert.pem. Once this is done, using the public key of www.linkedin.com it negotiates cipher TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 with a symmetric key. Subsequent data transfer including first HTTP request uses the same cipher and symmetric key.","title":"HTTP"},{"location":"level101/linux_networking/intro/","text":"Linux Networking Fundamentals Prerequisites High-level knowledge of commonly used jargon in TCP/IP stack like DNS, TCP, UDP and HTTP Linux Commandline Basics What to expect from this course Throughout the course, we cover how an SRE can optimize the system to improve their web stack performance and troubleshoot if there is an issue in any of the layers of the networking stack. This course tries to dig through each layer of traditional TCP/IP stack and expects an SRE to have a picture beyond the bird\u2019s eye view of the functioning of the Internet. What is not covered under this course This course spends time on the fundamentals. We are not covering concepts like HTTP/2.0 , QUIC , TCP congestion control protocols , Anycast , BGP , CDN , Tunnels and Multicast . We expect that this course will provide the relevant basics to understand such concepts Birds eye view of the course The course covers the question \u201cWhat happens when you open linkedin.com in your browser?\u201d The course follows the flow of TCP/IP stack.More specifically, the course covers topics of Application layer protocols DNS and HTTP, transport layer protocols UDP and TCP, networking layer protocol IP and Data Link Layer protocol Course Contents DNS UDP HTTP TCP IP Routing","title":"Introduction"},{"location":"level101/linux_networking/intro/#linux-networking-fundamentals","text":"","title":"Linux Networking Fundamentals"},{"location":"level101/linux_networking/intro/#prerequisites","text":"High-level knowledge of commonly used jargon in TCP/IP stack like DNS, TCP, UDP and HTTP Linux Commandline Basics","title":"Prerequisites"},{"location":"level101/linux_networking/intro/#what-to-expect-from-this-course","text":"Throughout the course, we cover how an SRE can optimize the system to improve their web stack performance and troubleshoot if there is an issue in any of the layers of the networking stack. This course tries to dig through each layer of traditional TCP/IP stack and expects an SRE to have a picture beyond the bird\u2019s eye view of the functioning of the Internet.","title":"What to expect from this course"},{"location":"level101/linux_networking/intro/#what-is-not-covered-under-this-course","text":"This course spends time on the fundamentals. We are not covering concepts like HTTP/2.0 , QUIC , TCP congestion control protocols , Anycast , BGP , CDN , Tunnels and Multicast . We expect that this course will provide the relevant basics to understand such concepts","title":"What is not covered under this course"},{"location":"level101/linux_networking/intro/#birds-eye-view-of-the-course","text":"The course covers the question \u201cWhat happens when you open linkedin.com in your browser?\u201d The course follows the flow of TCP/IP stack.More specifically, the course covers topics of Application layer protocols DNS and HTTP, transport layer protocols UDP and TCP, networking layer protocol IP and Data Link Layer protocol","title":"Birds eye view of the course"},{"location":"level101/linux_networking/intro/#course-contents","text":"DNS UDP HTTP TCP IP Routing","title":"Course Contents"},{"location":"level101/linux_networking/ipr/","text":"IP Routing and Data Link Layer We will dig how packets that leave the client reach the server and vice versa. When the packet reaches the IP layer, the transport layer populates source port, destination port. IP/Network layer populates destination IP(discovered from DNS) and then looks up the route to the destination IP on the routing table. #Linux route -n command gives the default routing table route -n Kernel IP routing table Destination Gateway Genmask Flags Metric Ref Use Iface 0.0.0.0 172.17.0.1 0.0.0.0 UG 0 0 0 eth0 172.17.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth0 Here the destination IP is bitwise AND\u2019d with the Genmask and if the answer is the destination part of the table then that gateway and interface is picked for routing. Here linkedin.com\u2019s IP 108.174.10.10 is AND\u2019d with 255.255.255.0 and the answer we get is 108.174.10.0 which doesn\u2019t match with any destination in the routing table. Then Linux does an AND of destination IP with 0.0.0.0 and we get 0.0.0.0. This answer matches the default row Routing table is processed in the order of more octets of 1 set in genmask and genmask 0.0.0.0 is the default route if nothing matches. At the end of this operation Linux figured out that the packet has to be sent to next hop 172.17.0.1 via eth0. The source IP of the packet will be set as the IP of interface eth0. Now to send the packet to 172.17.0.1 linux has to figure out the MAC address of 172.17.0.1. MAC address is figured by looking at the internal arp cache which stores translation between IP address and MAC address. If there is a cache miss, Linux broadcasts ARP request within the internal network asking who has 172.17.0.1. The owner of the IP sends an ARP response which is cached by the kernel and the kernel sends the packet to the gateway by setting Source mac address as mac address of eth0 and destination mac address of 172.17.0.1 which we got just now. Similar routing lookup process is followed in each hop till the packet reaches the actual server. Transport layer and layers above it come to play only at end servers. During intermediate hops only till the IP/Network layer is involved. One weird gateway we saw in the routing table is 0.0.0.0. This gateway means no Layer3(Network layer) hop is needed to send the packet. Both source and destination are in the same network. Kernel has to figure out the mac of the destination and populate source and destination mac appropriately and send the packet out so that it reaches the destination without any Layer3 hop in the middle As we followed in other modules, lets complete this session with SRE usecases Applications in SRE role Generally the routing table is populated by DHCP and playing around is not a good practice. There can be reasons where one has to play around the routing table but take that path only when it's absolutely necessary Understanding error messages better like, \u201cNo route to host\u201d error can mean mac address of the destination host is not found and it can mean the destination host is down On rare cases looking at the ARP table can help us understand if there is a IP conflict where same IP is assigned to two hosts by mistake and this is causing unexpected behavior","title":"Routing"},{"location":"level101/linux_networking/ipr/#ip-routing-and-data-link-layer","text":"We will dig how packets that leave the client reach the server and vice versa. When the packet reaches the IP layer, the transport layer populates source port, destination port. IP/Network layer populates destination IP(discovered from DNS) and then looks up the route to the destination IP on the routing table. #Linux route -n command gives the default routing table route -n Kernel IP routing table Destination Gateway Genmask Flags Metric Ref Use Iface 0.0.0.0 172.17.0.1 0.0.0.0 UG 0 0 0 eth0 172.17.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth0 Here the destination IP is bitwise AND\u2019d with the Genmask and if the answer is the destination part of the table then that gateway and interface is picked for routing. Here linkedin.com\u2019s IP 108.174.10.10 is AND\u2019d with 255.255.255.0 and the answer we get is 108.174.10.0 which doesn\u2019t match with any destination in the routing table. Then Linux does an AND of destination IP with 0.0.0.0 and we get 0.0.0.0. This answer matches the default row Routing table is processed in the order of more octets of 1 set in genmask and genmask 0.0.0.0 is the default route if nothing matches. At the end of this operation Linux figured out that the packet has to be sent to next hop 172.17.0.1 via eth0. The source IP of the packet will be set as the IP of interface eth0. Now to send the packet to 172.17.0.1 linux has to figure out the MAC address of 172.17.0.1. MAC address is figured by looking at the internal arp cache which stores translation between IP address and MAC address. If there is a cache miss, Linux broadcasts ARP request within the internal network asking who has 172.17.0.1. The owner of the IP sends an ARP response which is cached by the kernel and the kernel sends the packet to the gateway by setting Source mac address as mac address of eth0 and destination mac address of 172.17.0.1 which we got just now. Similar routing lookup process is followed in each hop till the packet reaches the actual server. Transport layer and layers above it come to play only at end servers. During intermediate hops only till the IP/Network layer is involved. One weird gateway we saw in the routing table is 0.0.0.0. This gateway means no Layer3(Network layer) hop is needed to send the packet. Both source and destination are in the same network. Kernel has to figure out the mac of the destination and populate source and destination mac appropriately and send the packet out so that it reaches the destination without any Layer3 hop in the middle As we followed in other modules, lets complete this session with SRE usecases","title":"IP Routing and Data Link Layer"},{"location":"level101/linux_networking/ipr/#applications-in-sre-role","text":"Generally the routing table is populated by DHCP and playing around is not a good practice. There can be reasons where one has to play around the routing table but take that path only when it's absolutely necessary Understanding error messages better like, \u201cNo route to host\u201d error can mean mac address of the destination host is not found and it can mean the destination host is down On rare cases looking at the ARP table can help us understand if there is a IP conflict where same IP is assigned to two hosts by mistake and this is causing unexpected behavior","title":"Applications in SRE role"},{"location":"level101/linux_networking/tcp/","text":"TCP TCP is a transport layer protocol like UDP but it guarantees reliability, flow control and congestion control. TCP guarantees reliable delivery by using sequence numbers. A TCP connection is established by a three way handshake. In our case, the client sends a SYN packet along with the starting sequence number it plans to use, the server acknowledges the SYN packet and sends a SYN with its sequence number. Once the client acknowledges the syn packet, the connection is established. Each data transferred from here on is considered delivered reliably once acknowledgement for that sequence is received by the concerned party #To understand handshake run packet capture on one bash session tcpdump -S -i any port 80 #Run curl on one bash session curl www.linkedin.com Here client sends a syn flag shown by [S] flag with a sequence number 1522264672. The server acknowledges receipt of SYN with an ack [.] flag and a Syn flag for its sequence number[S]. The server uses the sequence number 1063230400 and acknowledges the client it\u2019s expecting sequence number 1522264673 (client sequence+1). Client sends a zero length acknowledgement packet to the server(server sequence+1) and connection stands established. This is called three way handshake. The client sends a 76 bytes length packet after this and increments its sequence number by 76. Server sends a 170 byte response and closes the connection. This was the difference we were talking about between HTTP/1.1 and HTTP/1.0. In HTTP/1.1 this same connection can be reused which reduces overhead of 3 way handshake for each HTTP request. If a packet is missed between client and server, server won\u2019t send an ack to the client and client would retry sending the packet till the ACK is received. This guarantees reliability. The flow control is established by the win size field in each segment. The win size says available TCP buffer length in the kernel which can be used to buffer received segments. A size 0 means the receiver has a lot of lag to catch from its socket buffer and the sender has to pause sending packets so that receiver can cope up. This flow control protects from slow receiver and fast sender problem TCP also does congestion control which determines how many segments can be in transit without an ack. Linux provides us the ability to configure algorithms for congestion control which we are not covering here. While closing a connection, client/server calls a close syscall. Let's assume client do that. Client\u2019s kernel will send a FIN packet to the server. Server\u2019s kernel can\u2019t close the connection till the close syscall is called by the server application. Once server app calls close, server also sends a FIN packet and client enters into time wait state for 2*MSS(120s) so that this socket can\u2019t be reused for that time period to prevent any TCP state corruptions due to stray stale packets. Armed with our TCP and HTTP knowledge lets see how this is used by SREs in their role Applications in SRE role Scaling HTTP performance using load balancers need consistent knowledge about both TCP and HTTP. There are different kinds of load balancing like L4, L7 load balancing, Direct Server Return etc. HTTPs offloading can be done on Load balancer or directly on servers based on the performance and compliance needs. Tweaking sysctl variables for rmem and wmem like we did for UDP can improve throughput of sender and receiver. Sysctl variable tcp_max_syn_backlog and socket variable somax_conn determines how many connections for which the kernel can complete 3 way handshake before app calling accept syscall. This is much useful in single threaded applications. Once the backlog is full, new connections stay in SYN_RCVD state (when you run netstat) till the application calls accept syscall Apps can run out of file descriptors if there are too many short lived connections. Digging through tcp_reuse and tcp_recycle can help reduce time spent in the time wait state(it has its own risk). Making apps reuse a pool of connections instead of creating ad hoc connection can also help Understanding performance bottlenecks by seeing metrics and classifying whether its a problem in App or network side. Example too many sockets in Close_wait state is a problem on application whereas retransmissions can be a problem more on network or on OS stack than the application itself. Understanding the fundamentals can help us narrow down where the bottleneck is","title":"TCP"},{"location":"level101/linux_networking/tcp/#tcp","text":"TCP is a transport layer protocol like UDP but it guarantees reliability, flow control and congestion control. TCP guarantees reliable delivery by using sequence numbers. A TCP connection is established by a three way handshake. In our case, the client sends a SYN packet along with the starting sequence number it plans to use, the server acknowledges the SYN packet and sends a SYN with its sequence number. Once the client acknowledges the syn packet, the connection is established. Each data transferred from here on is considered delivered reliably once acknowledgement for that sequence is received by the concerned party #To understand handshake run packet capture on one bash session tcpdump -S -i any port 80 #Run curl on one bash session curl www.linkedin.com Here client sends a syn flag shown by [S] flag with a sequence number 1522264672. The server acknowledges receipt of SYN with an ack [.] flag and a Syn flag for its sequence number[S]. The server uses the sequence number 1063230400 and acknowledges the client it\u2019s expecting sequence number 1522264673 (client sequence+1). Client sends a zero length acknowledgement packet to the server(server sequence+1) and connection stands established. This is called three way handshake. The client sends a 76 bytes length packet after this and increments its sequence number by 76. Server sends a 170 byte response and closes the connection. This was the difference we were talking about between HTTP/1.1 and HTTP/1.0. In HTTP/1.1 this same connection can be reused which reduces overhead of 3 way handshake for each HTTP request. If a packet is missed between client and server, server won\u2019t send an ack to the client and client would retry sending the packet till the ACK is received. This guarantees reliability. The flow control is established by the win size field in each segment. The win size says available TCP buffer length in the kernel which can be used to buffer received segments. A size 0 means the receiver has a lot of lag to catch from its socket buffer and the sender has to pause sending packets so that receiver can cope up. This flow control protects from slow receiver and fast sender problem TCP also does congestion control which determines how many segments can be in transit without an ack. Linux provides us the ability to configure algorithms for congestion control which we are not covering here. While closing a connection, client/server calls a close syscall. Let's assume client do that. Client\u2019s kernel will send a FIN packet to the server. Server\u2019s kernel can\u2019t close the connection till the close syscall is called by the server application. Once server app calls close, server also sends a FIN packet and client enters into time wait state for 2*MSS(120s) so that this socket can\u2019t be reused for that time period to prevent any TCP state corruptions due to stray stale packets. Armed with our TCP and HTTP knowledge lets see how this is used by SREs in their role","title":"TCP"},{"location":"level101/linux_networking/tcp/#applications-in-sre-role","text":"Scaling HTTP performance using load balancers need consistent knowledge about both TCP and HTTP. There are different kinds of load balancing like L4, L7 load balancing, Direct Server Return etc. HTTPs offloading can be done on Load balancer or directly on servers based on the performance and compliance needs. Tweaking sysctl variables for rmem and wmem like we did for UDP can improve throughput of sender and receiver. Sysctl variable tcp_max_syn_backlog and socket variable somax_conn determines how many connections for which the kernel can complete 3 way handshake before app calling accept syscall. This is much useful in single threaded applications. Once the backlog is full, new connections stay in SYN_RCVD state (when you run netstat) till the application calls accept syscall Apps can run out of file descriptors if there are too many short lived connections. Digging through tcp_reuse and tcp_recycle can help reduce time spent in the time wait state(it has its own risk). Making apps reuse a pool of connections instead of creating ad hoc connection can also help Understanding performance bottlenecks by seeing metrics and classifying whether its a problem in App or network side. Example too many sockets in Close_wait state is a problem on application whereas retransmissions can be a problem more on network or on OS stack than the application itself. Understanding the fundamentals can help us narrow down where the bottleneck is","title":"Applications in SRE role"},{"location":"level101/linux_networking/udp/","text":"UDP UDP is a transport layer protocol. DNS is an application layer protocol that runs on top of UDP(most of the times). Before jumping into UDP, let's try to understand what an application and transport layer is. DNS protocol is used by a DNS client(eg dig) and DNS server(eg named). The transport layer makes sure the DNS request reaches the DNS server process and similarly the response reaches the DNS client process. Multiple processes can run on a system and they can listen on any ports . DNS servers usually listen on port number 53. When a client makes a DNS request, after filling the necessary application payload, it passes the payload to the kernel via sendto system call. The kernel picks a random port number( >1024 ) as source port number and puts 53 as destination port number and sends the packet to lower layers. When the kernel on server side receives the packet, it checks the port number and queues the packet to the application buffer of the DNS server process which makes a recvfrom system call and reads the packet. This process by the kernel is called multiplexing(combining packets from multiple applications to same lower layers) and demultiplexing(segregating packets from single lower layer to multiple applications). Multiplexing and Demultiplexing is done by the Transport layer. UDP is one of the simplest transport layer protocol and it does only multiplexing and demultiplexing. Another common transport layer protocol TCP does a bunch of other things like reliable communication, flow control and congestion control. UDP is designed to be lightweight and handle communications with little overhead. So it doesn\u2019t do anything beyond multiplexing and demultiplexing. If applications running on top of UDP need any of the features of TCP, they have to implement that in their application This example from python wiki covers a sample UDP client and server where \u201cHello World\u201d is an application payload sent to server listening on port number 5005. The server receives the packet and prints the \u201cHello World\u201d string from the client Applications in SRE role If the underlying network is slow and the UDP layer is unable to queue packets down to the networking layer, sendto syscall from the application will hang till the kernel finds some of its buffer is freed. This can affect the throughput of the system. Increasing write memory buffer values using sysctl variables net.core.wmem_max and net.core.wmem_default provides some cushion to the application from the slow network Similarly if the receiver process is slow in consuming from its buffer, the kernel has to drop packets which it can\u2019t queue due to the buffer being full. Since UDP doesn\u2019t guarantee reliability these dropped packets can cause data loss unless tracked by the application layer. Increasing sysctl variables rmem_default and rmem_max can provide some cushion to slow applications from fast senders.","title":"UDP"},{"location":"level101/linux_networking/udp/#udp","text":"UDP is a transport layer protocol. DNS is an application layer protocol that runs on top of UDP(most of the times). Before jumping into UDP, let's try to understand what an application and transport layer is. DNS protocol is used by a DNS client(eg dig) and DNS server(eg named). The transport layer makes sure the DNS request reaches the DNS server process and similarly the response reaches the DNS client process. Multiple processes can run on a system and they can listen on any ports . DNS servers usually listen on port number 53. When a client makes a DNS request, after filling the necessary application payload, it passes the payload to the kernel via sendto system call. The kernel picks a random port number( >1024 ) as source port number and puts 53 as destination port number and sends the packet to lower layers. When the kernel on server side receives the packet, it checks the port number and queues the packet to the application buffer of the DNS server process which makes a recvfrom system call and reads the packet. This process by the kernel is called multiplexing(combining packets from multiple applications to same lower layers) and demultiplexing(segregating packets from single lower layer to multiple applications). Multiplexing and Demultiplexing is done by the Transport layer. UDP is one of the simplest transport layer protocol and it does only multiplexing and demultiplexing. Another common transport layer protocol TCP does a bunch of other things like reliable communication, flow control and congestion control. UDP is designed to be lightweight and handle communications with little overhead. So it doesn\u2019t do anything beyond multiplexing and demultiplexing. If applications running on top of UDP need any of the features of TCP, they have to implement that in their application This example from python wiki covers a sample UDP client and server where \u201cHello World\u201d is an application payload sent to server listening on port number 5005. The server receives the packet and prints the \u201cHello World\u201d string from the client","title":"UDP"},{"location":"level101/linux_networking/udp/#applications-in-sre-role","text":"If the underlying network is slow and the UDP layer is unable to queue packets down to the networking layer, sendto syscall from the application will hang till the kernel finds some of its buffer is freed. This can affect the throughput of the system. Increasing write memory buffer values using sysctl variables net.core.wmem_max and net.core.wmem_default provides some cushion to the application from the slow network Similarly if the receiver process is slow in consuming from its buffer, the kernel has to drop packets which it can\u2019t queue due to the buffer being full. Since UDP doesn\u2019t guarantee reliability these dropped packets can cause data loss unless tracked by the application layer. Increasing sysctl variables rmem_default and rmem_max can provide some cushion to slow applications from fast senders.","title":"Applications in SRE role"},{"location":"level101/metrics_and_monitoring/alerts/","text":"Proactive monitoring using alerts Earlier we discussed different ways to collect key metric data points from a service and its underlying infrastructure. This data gives us a better understanding of how the service is performing. One of the main objectives of monitoring is to detect any service degradations early (reduce Mean Time To Detect) and notify stakeholders so that the issues are either avoided or can be fixed early, thus reducing Mean Time To Recover (MTTR). For example, if you are notified when resource usage by a service exceeds 90 percent, you can take preventive measures to avoid any service breakdown due to a shortage of resources. On the other hand, when a service goes down due to an issue, early detection and notification of such incidents can help you quickly fix the issue. Figure 8: An alert notification received on Slack Today most of the monitoring services available provide a mechanism to set up alerts on one or a combination of metrics to actively monitor the service health. These alerts have a set of defined rules or conditions, and when the rule is broken, you are notified. These rules can be as simple as notifying when the metric value exceeds n to as complex as a week over week (WoW) comparison of standard deviation over a period of time. Monitoring tools notify you about an active alert, and most of these tools support instant messaging (IM) platforms, SMS, email, or phone calls. Figure 8 shows a sample alert notification received on Slack for memory usage exceeding 90 percent of total RAM space on the host.","title":"Proactive Monitoring with Alerts"},{"location":"level101/metrics_and_monitoring/alerts/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/alerts/#proactive-monitoring-using-alerts","text":"Earlier we discussed different ways to collect key metric data points from a service and its underlying infrastructure. This data gives us a better understanding of how the service is performing. One of the main objectives of monitoring is to detect any service degradations early (reduce Mean Time To Detect) and notify stakeholders so that the issues are either avoided or can be fixed early, thus reducing Mean Time To Recover (MTTR). For example, if you are notified when resource usage by a service exceeds 90 percent, you can take preventive measures to avoid any service breakdown due to a shortage of resources. On the other hand, when a service goes down due to an issue, early detection and notification of such incidents can help you quickly fix the issue. Figure 8: An alert notification received on Slack Today most of the monitoring services available provide a mechanism to set up alerts on one or a combination of metrics to actively monitor the service health. These alerts have a set of defined rules or conditions, and when the rule is broken, you are notified. These rules can be as simple as notifying when the metric value exceeds n to as complex as a week over week (WoW) comparison of standard deviation over a period of time. Monitoring tools notify you about an active alert, and most of these tools support instant messaging (IM) platforms, SMS, email, or phone calls. Figure 8 shows a sample alert notification received on Slack for memory usage exceeding 90 percent of total RAM space on the host.","title":"Proactive monitoring using alerts"},{"location":"level101/metrics_and_monitoring/best_practices/","text":"Best practices for monitoring When setting up monitoring for a service, keep the following best practices in mind. Use the right metric type -- Most of the libraries available today offer various metric types. Choose the appropriate metric type for monitoring your system. Following are the types of metrics and their purposes. Gauge -- Gauge is a constant type of metric. After the metric is initialized, the metric value does not change unless you intentionally update it. Timer -- Timer measures the time taken to complete a task. Counter -- Counter counts the number of occurrences of a particular event. For more information about these metric types, see Data Types . Avoid over-monitoring -- Monitoring can be a significant engineering endeavor . Therefore, be sure not to spend too much time and resources on monitoring services, yet make sure all important metrics are captured. Prevent alert fatigue -- Set alerts for metrics that are important and actionable. If you receive too many non-critical alerts, you might start ignoring alert notifications over time. As a result, critical alerts might get overlooked. Have a runbook for alerts -- For every alert, make sure you have a document explaining what actions and checks need to be performed when the alert fires. This enables any engineer on the team to handle the alert and take necessary actions, without any help from others.","title":"Best Practices for Monitoring"},{"location":"level101/metrics_and_monitoring/best_practices/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/best_practices/#best-practices-for-monitoring","text":"When setting up monitoring for a service, keep the following best practices in mind. Use the right metric type -- Most of the libraries available today offer various metric types. Choose the appropriate metric type for monitoring your system. Following are the types of metrics and their purposes. Gauge -- Gauge is a constant type of metric. After the metric is initialized, the metric value does not change unless you intentionally update it. Timer -- Timer measures the time taken to complete a task. Counter -- Counter counts the number of occurrences of a particular event. For more information about these metric types, see Data Types . Avoid over-monitoring -- Monitoring can be a significant engineering endeavor . Therefore, be sure not to spend too much time and resources on monitoring services, yet make sure all important metrics are captured. Prevent alert fatigue -- Set alerts for metrics that are important and actionable. If you receive too many non-critical alerts, you might start ignoring alert notifications over time. As a result, critical alerts might get overlooked. Have a runbook for alerts -- For every alert, make sure you have a document explaining what actions and checks need to be performed when the alert fires. This enables any engineer on the team to handle the alert and take necessary actions, without any help from others.","title":"Best practices for monitoring"},{"location":"level101/metrics_and_monitoring/command-line_tools/","text":"Command-line tools Most of the Linux distributions today come with a set of tools that monitor the system's performance. These tools help you measure and understand various subsystem statistics (CPU, memory, network, and so on). Let's look at some of the tools that are predominantly used. ps/top -- The process status command (ps) displays information about all the currently running processes in a Linux system. The top command is similar to the ps command, but it periodically updates the information displayed until the program is terminated. An advanced version of top, called htop, has a more user-friendly interface and some additional features. These command-line utilities come with options to modify the operation and output of the command. Following are some important options supported by the ps command. -p -- Displays information about processes that match the specified process IDs. Similarly, you can use -u and -g to display information about processes belonging to a specific user or group. -a -- Displays information about other users' processes, as well as one's own. -x -- When displaying processes matched by other options, includes processes that do not have a controlling terminal. Figure 2: Results of top command ss -- The socket statistics command (ss) displays information about network sockets on the system. This tool is the successor of netstat , which is deprecated. Following are some command-line options supported by the ss command: -t -- Displays the TCP socket. Similarly, -u displays UDP sockets, -x is for UNIX domain sockets, and so on. -l -- Displays only listening sockets. -n -- Instructs the command to not resolve service names. Instead displays the port numbers. Figure 3: List of listening sockets on a system free -- The free command displays memory usage statistics on the host like available memory, used memory, and free memory. Most often, this command is used with the -h command-line option, which displays the statistics in a human-readable format. Figure 4: Memory statistics on a host in human-readable form df -- The df command displays disk space usage statistics. The -i command-line option is also often used to display inode usage statistics. The -h command-line option is used for displaying statistics in a human-readable format. Figure 5: Disk usage statistics on a system in human-readable form sar -- The sar utility monitors various subsystems, such as CPU and memory, in real time. This data can be stored in a file specified with the -o option. This tool helps to identify anomalies. iftop -- The interface top command ( iftop ) displays bandwidth utilization by a host on an interface. This command is often used to identify bandwidth usage by active connections. The -i option specifies which network interface to watch. Figure 6: Network bandwidth usage by active connection on the host tcpdump -- The tcpdump command is a network monitoring tool that captures network packets flowing over the network and displays a description of the captured packets. The following options are available: -i -- Interface to listen on host -- Filters traffic going to or from the specified host src/dst -- Displays one-way traffic from the source (src) or to the destination (dst) port -- Filters traffic to or from a particular port Figure 7: *tcpdump* of packets on *docker0* interface on a host","title":"Command-line Tools"},{"location":"level101/metrics_and_monitoring/command-line_tools/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/command-line_tools/#command-line-tools","text":"Most of the Linux distributions today come with a set of tools that monitor the system's performance. These tools help you measure and understand various subsystem statistics (CPU, memory, network, and so on). Let's look at some of the tools that are predominantly used. ps/top -- The process status command (ps) displays information about all the currently running processes in a Linux system. The top command is similar to the ps command, but it periodically updates the information displayed until the program is terminated. An advanced version of top, called htop, has a more user-friendly interface and some additional features. These command-line utilities come with options to modify the operation and output of the command. Following are some important options supported by the ps command. -p -- Displays information about processes that match the specified process IDs. Similarly, you can use -u and -g to display information about processes belonging to a specific user or group. -a -- Displays information about other users' processes, as well as one's own. -x -- When displaying processes matched by other options, includes processes that do not have a controlling terminal. Figure 2: Results of top command ss -- The socket statistics command (ss) displays information about network sockets on the system. This tool is the successor of netstat , which is deprecated. Following are some command-line options supported by the ss command: -t -- Displays the TCP socket. Similarly, -u displays UDP sockets, -x is for UNIX domain sockets, and so on. -l -- Displays only listening sockets. -n -- Instructs the command to not resolve service names. Instead displays the port numbers. Figure 3: List of listening sockets on a system free -- The free command displays memory usage statistics on the host like available memory, used memory, and free memory. Most often, this command is used with the -h command-line option, which displays the statistics in a human-readable format. Figure 4: Memory statistics on a host in human-readable form df -- The df command displays disk space usage statistics. The -i command-line option is also often used to display inode usage statistics. The -h command-line option is used for displaying statistics in a human-readable format. Figure 5: Disk usage statistics on a system in human-readable form sar -- The sar utility monitors various subsystems, such as CPU and memory, in real time. This data can be stored in a file specified with the -o option. This tool helps to identify anomalies. iftop -- The interface top command ( iftop ) displays bandwidth utilization by a host on an interface. This command is often used to identify bandwidth usage by active connections. The -i option specifies which network interface to watch. Figure 6: Network bandwidth usage by active connection on the host tcpdump -- The tcpdump command is a network monitoring tool that captures network packets flowing over the network and displays a description of the captured packets. The following options are available: -i -- Interface to listen on host -- Filters traffic going to or from the specified host src/dst -- Displays one-way traffic from the source (src) or to the destination (dst) port -- Filters traffic to or from a particular port Figure 7: *tcpdump* of packets on *docker0* interface on a host","title":"Command-line tools"},{"location":"level101/metrics_and_monitoring/conclusion/","text":"Conclusion A robust monitoring and alerting system is necessary for maintaining and troubleshooting a system. A dashboard with key metrics can give you an overview of service performance, all in one place. Well-defined alerts (with realistic thresholds and notifications) further enable you to quickly identify any anomalies in the service infrastructure and in resource saturation. By taking necessary actions, you can avoid any service degradations and decrease MTTD for service breakdowns. In addition to in-house monitoring, monitoring real user experience can help you to understand service performance as perceived by the users. Many modules are involved in serving the user, and most of them are out of your control. Therefore, you need to have real-user monitoring in place. Metrics give very abstract details on service performance. To get a better understanding of the system and for faster recovery during incidents, you might want to implement the other two pillars of observability: logs and tracing. Logs and trace data can help you understand what led to service failure or degradation. Following are some resources to learn more about monitoring and observability: Google SRE book: Monitoring Distributed Systems Mastering Distributed Tracing by Yuri Shkuro References Google SRE book: Monitoring Distributed Systems Mastering Distributed Tracing, by Yuri Shkuro Monitoring and Observability Three PIllars with Zero Answers Engineering blogs on LinkedIn , Grafana , Elastic.co , OpenTelemetry","title":"Conclusion"},{"location":"level101/metrics_and_monitoring/conclusion/#conclusion","text":"A robust monitoring and alerting system is necessary for maintaining and troubleshooting a system. A dashboard with key metrics can give you an overview of service performance, all in one place. Well-defined alerts (with realistic thresholds and notifications) further enable you to quickly identify any anomalies in the service infrastructure and in resource saturation. By taking necessary actions, you can avoid any service degradations and decrease MTTD for service breakdowns. In addition to in-house monitoring, monitoring real user experience can help you to understand service performance as perceived by the users. Many modules are involved in serving the user, and most of them are out of your control. Therefore, you need to have real-user monitoring in place. Metrics give very abstract details on service performance. To get a better understanding of the system and for faster recovery during incidents, you might want to implement the other two pillars of observability: logs and tracing. Logs and trace data can help you understand what led to service failure or degradation. Following are some resources to learn more about monitoring and observability: Google SRE book: Monitoring Distributed Systems Mastering Distributed Tracing by Yuri Shkuro","title":"Conclusion"},{"location":"level101/metrics_and_monitoring/conclusion/#references","text":"Google SRE book: Monitoring Distributed Systems Mastering Distributed Tracing, by Yuri Shkuro Monitoring and Observability Three PIllars with Zero Answers Engineering blogs on LinkedIn , Grafana , Elastic.co , OpenTelemetry","title":"References"},{"location":"level101/metrics_and_monitoring/introduction/","text":"Prerequisites Linux Basics Python and the Web Systems Design Linux Networking Fundamentals What to expect from this course Monitoring is an integral part of any system. As an SRE, you need to have a basic understanding of monitoring a service infrastructure. By the end of this course, you will gain a better understanding of the following topics: What is monitoring? What needs to be measured How the metrics gathered can be used to improve business decisions and overall reliability Proactive monitoring with alerts Log processing and its importance What is observability? Distributed tracing Logs Metrics What is not covered in this course Guide to setting up a monitoring infrastructure Deep dive into different monitoring technologies and benchmarking or comparison of any tools Course content Introduction Four golden signals of monitoring Why is monitoring important? Command-line tools Third-party monitoring Proactive monitoring using alerts Best practices for monitoring Observability Logs Tracing Conclusion Introduction Monitoring is a process of collecting real-time performance metrics from a system, analyzing the data to derive meaningful information, and displaying the data to the users. In simple terms, you measure various metrics regularly to understand the state of the system, including but not limited to, user requests, latency, and error rate. What gets measured, gets fixed ---if you can measure something, you can reason about it, understand it, discuss it, and act upon it with confidence. Four golden signals of monitoring When setting up monitoring for a system, you need to decide what to measure. The four golden signals of monitoring provide a good understanding of service performance and lay a foundation for monitoring a system. These four golden signals are Traffic Latency Error Saturation These metrics help you to understand the system performance and bottlenecks, and to create a better end-user experience. As discussed in the Google SRE book , if you can measure only four metrics of your service, focus on these four. Let's look at each of the four golden signals. Traffic -- Traffic gives a better understanding of the service demand. Often referred to as service QPS (queries per second), traffic is a measure of requests served by the service. This signal helps you to decide when a service needs to be scaled up to handle increasing customer demand and scaled down to be cost-effective. Latency -- Latency is the measure of time taken by the service to process the incoming request and send the response. Measuring service latency helps in the early detection of slow degradation of the service. Distinguishing between the latency of successful requests and the latency of failed requests is important. For example, an HTTP 5XX error triggered due to loss of connection to a database or other critical backend might be served very quickly. However, because an HTTP 500 error indicates a failed request, factoring 500s into overall latency might result in misleading calculations. Error (rate) -- Error is the measure of failed client requests. These failures can be easily identified based on the response codes ( HTTP 5XX error ). There might be cases where the response is considered erroneous due to wrong result data or due to policy violations. For example, you might get an HTTP 200 response, but the body has incomplete data, or response time is breaching the agreed-upon SLA s. Therefore, you need to have other mechanisms (code logic or instrumentation ) in place to capture errors in addition to the response codes. Saturation -- Saturation is a measure of the resource utilization by a service. This signal tells you the state of service resources and how full they are. These resources include memory, compute, network I/O, and so on. Service performance slowly degrades even before resource utilization is at 100 percent. Therefore, having a utilization target is important. An increase in latency is a good indicator of saturation; measuring the 99th percentile of latency can help in the early detection of saturation. Depending on the type of service, you can measure these signals in different ways. For example, you might measure queries per second served for a web server. In contrast, for a database server, transactions performed and database sessions created give you an idea about the traffic handled by the database server. With the help of additional code logic (monitoring libraries and instrumentation), you can measure these signals periodically and store them for future analysis. Although these metrics give you an idea about the performance at the service end, you need to also ensure that the same user experience is delivered at the client end. Therefore, you might need to monitor the service from outside the service infrastructure, which is discussed under third-party monitoring. Why is monitoring important? Monitoring plays a key role in the success of a service. As discussed earlier, monitoring provides performance insights for understanding service health. With access to historical data collected over time, you can build intelligent applications to address specific needs. Some of the key use cases follow: Reduction in time to resolve issues -- With a good monitoring infrastructure in place, you can identify issues quickly and resolve them, which reduces the impact caused by the issues. Business decisions -- Data collected over a period of time can help you make business decisions such as determining the product release cycle, which features to invest in, and geographical areas to focus on. Decisions based on long-term data can improve the overall product experience. Resource planning -- By analyzing historical data, you can forecast service compute-resource demands, and you can properly allocate resources. This allows financially effective decisions, with no compromise in end-user experience. Before we dive deeper into monitoring, let's understand some basic terminologies. Metric -- A metric is a quantitative measure of a particular system attribute---for example, memory or CPU Node or host -- A physical server, virtual machine, or container where an application is running QPS -- Queries Per Second , a measure of traffic served by the service per second Latency -- The time interval between user action and the response from the server---for example, time spent after sending a query to a database before the first response bit is received Error rate -- Number of errors observed over a particular time period (usually a second) Graph -- In monitoring, a graph is a representation of one or more values of metrics collected over time Dashboard -- A dashboard is a collection of graphs that provide an overview of system health Incident -- An incident is an event that disrupts the normal operations of a system MTTD -- Mean Time To Detect is the time interval between the beginning of a service failure and the detection of such failure MTTR -- Mean Time To Resolve is the time spent to fix a service failure and bring the service back to its normal state Before we discuss monitoring an application, let us look at the monitoring infrastructure. Following is an illustration of a basic monitoring system. Figure 1: Illustration of a monitoring infrastructure Figure 1 shows a monitoring infrastructure mechanism for aggregating metrics on the system, and collecting and storing the data for display. In addition, a monitoring infrastructure includes alert subsystems for notifying concerned parties during any abnormal behavior. Let's look at each of these infrastructure components: Host metrics agent -- A host metrics agent is a process running on the host that collects performance statistics for host subsystems such as memory, CPU, and network. These metrics are regularly relayed to a metrics collector for storage and visualization. Some examples are collectd , telegraf , and metricbeat . Metric aggregator -- A metric aggregator is a process running on the host. Applications running on the host collect service metrics using instrumentation . Collected metrics are sent either to the aggregator process or directly to the metrics collector over API, if available. Received metrics are aggregated periodically and relayed to the metrics collector in batches. An example is StatsD . Metrics collector -- A metrics collector process collects all the metrics from the metric aggregators running on multiple hosts. The collector takes care of decoding and stores this data on the database. Metric collection and storage might be taken care of by one single service such as InfluxDB , which we discuss next. An example is carbon daemons . Storage -- A time-series database stores all of these metrics. Examples are OpenTSDB , Whisper , and InfluxDB . Metrics server -- A metrics server can be as basic as a web server that graphically renders metric data. In addition, the metrics server provides aggregation functionalities and APIs for fetching metric data programmatically. Some examples are Grafana and Graphite-Web . Alert manager -- The alert manager regularly polls metric data available and, if there are any anomalies detected, notifies you. Each alert has a set of rules for identifying such anomalies. Today many metrics servers such as Grafana support alert management. We discuss alerting in detail later . Examples are Grafana and Icinga .","title":"Introduction"},{"location":"level101/metrics_and_monitoring/introduction/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/introduction/#prerequisites","text":"Linux Basics Python and the Web Systems Design Linux Networking Fundamentals","title":"Prerequisites"},{"location":"level101/metrics_and_monitoring/introduction/#what-to-expect-from-this-course","text":"Monitoring is an integral part of any system. As an SRE, you need to have a basic understanding of monitoring a service infrastructure. By the end of this course, you will gain a better understanding of the following topics: What is monitoring? What needs to be measured How the metrics gathered can be used to improve business decisions and overall reliability Proactive monitoring with alerts Log processing and its importance What is observability? Distributed tracing Logs Metrics","title":"What to expect from this course"},{"location":"level101/metrics_and_monitoring/introduction/#what-is-not-covered-in-this-course","text":"Guide to setting up a monitoring infrastructure Deep dive into different monitoring technologies and benchmarking or comparison of any tools","title":"What is not covered in this course"},{"location":"level101/metrics_and_monitoring/introduction/#course-content","text":"Introduction Four golden signals of monitoring Why is monitoring important? Command-line tools Third-party monitoring Proactive monitoring using alerts Best practices for monitoring Observability Logs Tracing Conclusion","title":"Course content"},{"location":"level101/metrics_and_monitoring/introduction/#_2","text":"","title":""},{"location":"level101/metrics_and_monitoring/introduction/#introduction","text":"Monitoring is a process of collecting real-time performance metrics from a system, analyzing the data to derive meaningful information, and displaying the data to the users. In simple terms, you measure various metrics regularly to understand the state of the system, including but not limited to, user requests, latency, and error rate. What gets measured, gets fixed ---if you can measure something, you can reason about it, understand it, discuss it, and act upon it with confidence.","title":"Introduction"},{"location":"level101/metrics_and_monitoring/introduction/#four-golden-signals-of-monitoring","text":"When setting up monitoring for a system, you need to decide what to measure. The four golden signals of monitoring provide a good understanding of service performance and lay a foundation for monitoring a system. These four golden signals are Traffic Latency Error Saturation These metrics help you to understand the system performance and bottlenecks, and to create a better end-user experience. As discussed in the Google SRE book , if you can measure only four metrics of your service, focus on these four. Let's look at each of the four golden signals. Traffic -- Traffic gives a better understanding of the service demand. Often referred to as service QPS (queries per second), traffic is a measure of requests served by the service. This signal helps you to decide when a service needs to be scaled up to handle increasing customer demand and scaled down to be cost-effective. Latency -- Latency is the measure of time taken by the service to process the incoming request and send the response. Measuring service latency helps in the early detection of slow degradation of the service. Distinguishing between the latency of successful requests and the latency of failed requests is important. For example, an HTTP 5XX error triggered due to loss of connection to a database or other critical backend might be served very quickly. However, because an HTTP 500 error indicates a failed request, factoring 500s into overall latency might result in misleading calculations. Error (rate) -- Error is the measure of failed client requests. These failures can be easily identified based on the response codes ( HTTP 5XX error ). There might be cases where the response is considered erroneous due to wrong result data or due to policy violations. For example, you might get an HTTP 200 response, but the body has incomplete data, or response time is breaching the agreed-upon SLA s. Therefore, you need to have other mechanisms (code logic or instrumentation ) in place to capture errors in addition to the response codes. Saturation -- Saturation is a measure of the resource utilization by a service. This signal tells you the state of service resources and how full they are. These resources include memory, compute, network I/O, and so on. Service performance slowly degrades even before resource utilization is at 100 percent. Therefore, having a utilization target is important. An increase in latency is a good indicator of saturation; measuring the 99th percentile of latency can help in the early detection of saturation. Depending on the type of service, you can measure these signals in different ways. For example, you might measure queries per second served for a web server. In contrast, for a database server, transactions performed and database sessions created give you an idea about the traffic handled by the database server. With the help of additional code logic (monitoring libraries and instrumentation), you can measure these signals periodically and store them for future analysis. Although these metrics give you an idea about the performance at the service end, you need to also ensure that the same user experience is delivered at the client end. Therefore, you might need to monitor the service from outside the service infrastructure, which is discussed under third-party monitoring.","title":"Four golden signals of monitoring"},{"location":"level101/metrics_and_monitoring/introduction/#why-is-monitoring-important","text":"Monitoring plays a key role in the success of a service. As discussed earlier, monitoring provides performance insights for understanding service health. With access to historical data collected over time, you can build intelligent applications to address specific needs. Some of the key use cases follow: Reduction in time to resolve issues -- With a good monitoring infrastructure in place, you can identify issues quickly and resolve them, which reduces the impact caused by the issues. Business decisions -- Data collected over a period of time can help you make business decisions such as determining the product release cycle, which features to invest in, and geographical areas to focus on. Decisions based on long-term data can improve the overall product experience. Resource planning -- By analyzing historical data, you can forecast service compute-resource demands, and you can properly allocate resources. This allows financially effective decisions, with no compromise in end-user experience. Before we dive deeper into monitoring, let's understand some basic terminologies. Metric -- A metric is a quantitative measure of a particular system attribute---for example, memory or CPU Node or host -- A physical server, virtual machine, or container where an application is running QPS -- Queries Per Second , a measure of traffic served by the service per second Latency -- The time interval between user action and the response from the server---for example, time spent after sending a query to a database before the first response bit is received Error rate -- Number of errors observed over a particular time period (usually a second) Graph -- In monitoring, a graph is a representation of one or more values of metrics collected over time Dashboard -- A dashboard is a collection of graphs that provide an overview of system health Incident -- An incident is an event that disrupts the normal operations of a system MTTD -- Mean Time To Detect is the time interval between the beginning of a service failure and the detection of such failure MTTR -- Mean Time To Resolve is the time spent to fix a service failure and bring the service back to its normal state Before we discuss monitoring an application, let us look at the monitoring infrastructure. Following is an illustration of a basic monitoring system. Figure 1: Illustration of a monitoring infrastructure Figure 1 shows a monitoring infrastructure mechanism for aggregating metrics on the system, and collecting and storing the data for display. In addition, a monitoring infrastructure includes alert subsystems for notifying concerned parties during any abnormal behavior. Let's look at each of these infrastructure components: Host metrics agent -- A host metrics agent is a process running on the host that collects performance statistics for host subsystems such as memory, CPU, and network. These metrics are regularly relayed to a metrics collector for storage and visualization. Some examples are collectd , telegraf , and metricbeat . Metric aggregator -- A metric aggregator is a process running on the host. Applications running on the host collect service metrics using instrumentation . Collected metrics are sent either to the aggregator process or directly to the metrics collector over API, if available. Received metrics are aggregated periodically and relayed to the metrics collector in batches. An example is StatsD . Metrics collector -- A metrics collector process collects all the metrics from the metric aggregators running on multiple hosts. The collector takes care of decoding and stores this data on the database. Metric collection and storage might be taken care of by one single service such as InfluxDB , which we discuss next. An example is carbon daemons . Storage -- A time-series database stores all of these metrics. Examples are OpenTSDB , Whisper , and InfluxDB . Metrics server -- A metrics server can be as basic as a web server that graphically renders metric data. In addition, the metrics server provides aggregation functionalities and APIs for fetching metric data programmatically. Some examples are Grafana and Graphite-Web . Alert manager -- The alert manager regularly polls metric data available and, if there are any anomalies detected, notifies you. Each alert has a set of rules for identifying such anomalies. Today many metrics servers such as Grafana support alert management. We discuss alerting in detail later . Examples are Grafana and Icinga .","title":"Why is monitoring important?"},{"location":"level101/metrics_and_monitoring/observability/","text":"Observability Engineers often use observability when referring to building reliable systems. Observability is a term derived from control theory, It is a measure of how well internal states of a system can be inferred from knowledge of its external outputs. Service infrastructures used on a daily basis are becoming more and more complex; proactive monitoring alone is not sufficient to quickly resolve issues causing application failures. With monitoring, you can keep known past failures from recurring, but with a complex service architecture, many unknown factors can cause potential problems. To address such cases, you can make the service observable. An observable system provides highly granular insights into the implicit failure modes. In addition, an observable system furnishes ample context about its inner workings, which unlocks the ability to uncover deeper systemic issues. Monitoring enables failure detection; observability helps in gaining a better understanding of the system. Among engineers, there is a common misconception that monitoring and observability are two different things. Actually, observability is the superset to monitoring; that is, monitoring improves service observability. The goal of observability is not only to detect problems, but also to understand where the issue is and what is causing it. In addition to metrics, observability has two more pillars: logs and traces, as shown in Figure 9. Although these three components do not make a system 100 percent observable, these are the most important and powerful components that give a better understanding of the system. Each of these pillars has its flaws, which are described in Three Pillars with Zero Answers . Figure 9: Three pillars of observability Because we have covered metrics already, let's look at the other two pillars (logs and traces). Logs Logs (often referred to as events ) are a record of activities performed by a service during its run time, with a corresponding timestamp. Metrics give abstract information about degradations in a system, and logs give a detailed view of what is causing these degradations. Logs created by the applications and infrastructure components help in effectively understanding the behavior of the system by providing details on application errors, exceptions, and event timelines. Logs help you to go back in time to understand the events that led to a failure. Therefore, examining logs is essential to troubleshooting system failures. Log processing involves the aggregation of different logs from individual applications and their subsequent shipment to central storage. Moving logs to central storage helps to preserve the logs, in case the application instances are inaccessible, or the application crashes due to a failure. After the logs are available in a central place, you can analyze the logs to derive sensible information from them. For audit and compliance purposes, you archive these logs on the central storage for a certain period of time. Log analyzers fetch useful information from log lines, such as request user information, request URL (feature), and response headers (such as content length) and response time. This information is grouped based on these attributes and made available to you through a visualization tool for quick understanding. You might be wondering how this log information helps. This information gives a holistic view of activities performed on all the involved entities. For example, let's say someone is performing a DoS (denial of service) attack on a web application. With the help of log processing, you can quickly look at top client IPs derived from access logs and identify where the attack is coming from. Similarly, if a feature in an application is causing a high error rate when accessed with a particular request parameter value, the results of log analysis can help you to quickly identify the misbehaving parameter value and take further action. Figure 10: Log processing and analysis using ELK stack Figure 10 shows a log processing platform using ELK (Elasticsearch, Logstash, Kibana), which provides centralized log processing. Beats is a collection of lightweight data shippers that can ship logs, audit data, network data, and so on over the network. In this use case specifically, we are using filebeat as a log shipper. Filebeat watches service log files and ships the log data to Logstash. Logstash parses these logs and transforms the data, preparing it to store on Elasticsearch. Transformed log data is stored on Elasticsearch and indexed for fast retrieval. Kibana searches and displays log data stored on Elasticsearch. Kibana also provides a set of visualizations for graphically displaying summaries derived from log data. Storing logs is expensive. And extensive logging of every event on the server is costly and takes up more storage space. With an increasing number of services, this cost can increase proportionally to the number of services. Tracing So far, we covered the importance of metrics and logging. Metrics give an abstract overview of the system, and logging gives a record of events that occurred. Imagine a complex distributed system with multiple microservices, where a user request is processed by multiple microservices in the system. Metrics and logging give you some information about how these requests are being handled by the system, but they fail to provide detailed information across all the microservices and how they affect a particular client request. If a slow downstream microservice is leading to increased response times, you need to have detailed visibility across all involved microservices to identify such microservice. The answer to this need is a request tracing mechanism. A trace is a series of spans, where each span is a record of events performed by different microservices to serve the client's request. In simple terms, a trace is a log of client-request serving derived from various microservices across different physical machines. Each span includes span metadata such as trace ID and span ID, and context, which includes information about transactions performed. Figure 11: Trace and spans for a URL shortener request Figure 11 is a graphical representation of a trace captured on the URL shortener example we covered earlier while learning Python. Similar to monitoring, the tracing infrastructure comprises a few modules for collecting traces, storing them, and accessing them. Each microservice runs a tracing library that collects traces in the background, creates in-memory batches, and submits the tracing backend. The tracing backend normalizes received trace data and stores it on persistent storage. Tracing data comes from multiple different microservices; therefore, trace storage is often organized to store data incrementally and is indexed by trace identifier. This organization helps in the reconstruction of trace data and in visualization. Figure 12 illustrates the anatomy of the distributed system. Figure 12: Anatomy of distributed tracing Today a set of tools and frameworks are available for building distributed tracing solutions. Following are some of the popular tools: OpenTelemetry : Observability framework for cloud-native software Jaeger : Open-source distributed tracing solution Zipkin : Open-source distributed tracing solution","title":"Observability"},{"location":"level101/metrics_and_monitoring/observability/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/observability/#observability","text":"Engineers often use observability when referring to building reliable systems. Observability is a term derived from control theory, It is a measure of how well internal states of a system can be inferred from knowledge of its external outputs. Service infrastructures used on a daily basis are becoming more and more complex; proactive monitoring alone is not sufficient to quickly resolve issues causing application failures. With monitoring, you can keep known past failures from recurring, but with a complex service architecture, many unknown factors can cause potential problems. To address such cases, you can make the service observable. An observable system provides highly granular insights into the implicit failure modes. In addition, an observable system furnishes ample context about its inner workings, which unlocks the ability to uncover deeper systemic issues. Monitoring enables failure detection; observability helps in gaining a better understanding of the system. Among engineers, there is a common misconception that monitoring and observability are two different things. Actually, observability is the superset to monitoring; that is, monitoring improves service observability. The goal of observability is not only to detect problems, but also to understand where the issue is and what is causing it. In addition to metrics, observability has two more pillars: logs and traces, as shown in Figure 9. Although these three components do not make a system 100 percent observable, these are the most important and powerful components that give a better understanding of the system. Each of these pillars has its flaws, which are described in Three Pillars with Zero Answers . Figure 9: Three pillars of observability Because we have covered metrics already, let's look at the other two pillars (logs and traces).","title":"Observability"},{"location":"level101/metrics_and_monitoring/observability/#logs","text":"Logs (often referred to as events ) are a record of activities performed by a service during its run time, with a corresponding timestamp. Metrics give abstract information about degradations in a system, and logs give a detailed view of what is causing these degradations. Logs created by the applications and infrastructure components help in effectively understanding the behavior of the system by providing details on application errors, exceptions, and event timelines. Logs help you to go back in time to understand the events that led to a failure. Therefore, examining logs is essential to troubleshooting system failures. Log processing involves the aggregation of different logs from individual applications and their subsequent shipment to central storage. Moving logs to central storage helps to preserve the logs, in case the application instances are inaccessible, or the application crashes due to a failure. After the logs are available in a central place, you can analyze the logs to derive sensible information from them. For audit and compliance purposes, you archive these logs on the central storage for a certain period of time. Log analyzers fetch useful information from log lines, such as request user information, request URL (feature), and response headers (such as content length) and response time. This information is grouped based on these attributes and made available to you through a visualization tool for quick understanding. You might be wondering how this log information helps. This information gives a holistic view of activities performed on all the involved entities. For example, let's say someone is performing a DoS (denial of service) attack on a web application. With the help of log processing, you can quickly look at top client IPs derived from access logs and identify where the attack is coming from. Similarly, if a feature in an application is causing a high error rate when accessed with a particular request parameter value, the results of log analysis can help you to quickly identify the misbehaving parameter value and take further action. Figure 10: Log processing and analysis using ELK stack Figure 10 shows a log processing platform using ELK (Elasticsearch, Logstash, Kibana), which provides centralized log processing. Beats is a collection of lightweight data shippers that can ship logs, audit data, network data, and so on over the network. In this use case specifically, we are using filebeat as a log shipper. Filebeat watches service log files and ships the log data to Logstash. Logstash parses these logs and transforms the data, preparing it to store on Elasticsearch. Transformed log data is stored on Elasticsearch and indexed for fast retrieval. Kibana searches and displays log data stored on Elasticsearch. Kibana also provides a set of visualizations for graphically displaying summaries derived from log data. Storing logs is expensive. And extensive logging of every event on the server is costly and takes up more storage space. With an increasing number of services, this cost can increase proportionally to the number of services.","title":"Logs"},{"location":"level101/metrics_and_monitoring/observability/#tracing","text":"So far, we covered the importance of metrics and logging. Metrics give an abstract overview of the system, and logging gives a record of events that occurred. Imagine a complex distributed system with multiple microservices, where a user request is processed by multiple microservices in the system. Metrics and logging give you some information about how these requests are being handled by the system, but they fail to provide detailed information across all the microservices and how they affect a particular client request. If a slow downstream microservice is leading to increased response times, you need to have detailed visibility across all involved microservices to identify such microservice. The answer to this need is a request tracing mechanism. A trace is a series of spans, where each span is a record of events performed by different microservices to serve the client's request. In simple terms, a trace is a log of client-request serving derived from various microservices across different physical machines. Each span includes span metadata such as trace ID and span ID, and context, which includes information about transactions performed. Figure 11: Trace and spans for a URL shortener request Figure 11 is a graphical representation of a trace captured on the URL shortener example we covered earlier while learning Python. Similar to monitoring, the tracing infrastructure comprises a few modules for collecting traces, storing them, and accessing them. Each microservice runs a tracing library that collects traces in the background, creates in-memory batches, and submits the tracing backend. The tracing backend normalizes received trace data and stores it on persistent storage. Tracing data comes from multiple different microservices; therefore, trace storage is often organized to store data incrementally and is indexed by trace identifier. This organization helps in the reconstruction of trace data and in visualization. Figure 12 illustrates the anatomy of the distributed system. Figure 12: Anatomy of distributed tracing Today a set of tools and frameworks are available for building distributed tracing solutions. Following are some of the popular tools: OpenTelemetry : Observability framework for cloud-native software Jaeger : Open-source distributed tracing solution Zipkin : Open-source distributed tracing solution","title":"Tracing"},{"location":"level101/metrics_and_monitoring/third-party_monitoring/","text":"Third-party monitoring Today most cloud providers offer a variety of monitoring solutions. In addition, a number of companies such as Datadog offer monitoring-as-a-service. In this section, we are not covering monitoring-as-a-service in depth. In recent years, more and more people have access to the internet. Many services are offered online to cater to the increasing user base. As a result, web pages are becoming larger, with increased client-side scripts. Users want these services to be fast and error-free. From the service point of view, when the response body is composed, an HTTP 200 OK response is sent, and everything looks okay. But there might be errors during transmission or on the client side. As previously mentioned, monitoring services from within the service infrastructure give good visibility into service health, but this is not enough. You need to monitor user experience, specifically the availability of services for clients. A number of third-party services such asf Catchpoint , Pingdom , and so on are available for achieving this goal. Third-party monitoring services can generate synthetic traffic simulating user requests from various parts of the world, to ensure the service is globally accessible. Other third-party monitoring solutions for real user monitoring (RUM) provide performance statistics such as service uptime and response time, from different geographical locations. This allows you to monitor the user experience from these locations, which might have different internet backbones, different operating systems, and different browsers and browser versions. Catchpoint Global Monitoring Network is a comprehensive 3-minute video that explains the importance of monitoring the client experience.","title":"Third-party Monitoring"},{"location":"level101/metrics_and_monitoring/third-party_monitoring/#_1","text":"","title":""},{"location":"level101/metrics_and_monitoring/third-party_monitoring/#third-party-monitoring","text":"Today most cloud providers offer a variety of monitoring solutions. In addition, a number of companies such as Datadog offer monitoring-as-a-service. In this section, we are not covering monitoring-as-a-service in depth. In recent years, more and more people have access to the internet. Many services are offered online to cater to the increasing user base. As a result, web pages are becoming larger, with increased client-side scripts. Users want these services to be fast and error-free. From the service point of view, when the response body is composed, an HTTP 200 OK response is sent, and everything looks okay. But there might be errors during transmission or on the client side. As previously mentioned, monitoring services from within the service infrastructure give good visibility into service health, but this is not enough. You need to monitor user experience, specifically the availability of services for clients. A number of third-party services such asf Catchpoint , Pingdom , and so on are available for achieving this goal. Third-party monitoring services can generate synthetic traffic simulating user requests from various parts of the world, to ensure the service is globally accessible. Other third-party monitoring solutions for real user monitoring (RUM) provide performance statistics such as service uptime and response time, from different geographical locations. This allows you to monitor the user experience from these locations, which might have different internet backbones, different operating systems, and different browsers and browser versions. Catchpoint Global Monitoring Network is a comprehensive 3-minute video that explains the importance of monitoring the client experience.","title":"Third-party monitoring"},{"location":"level101/python_web/intro/","text":"Python and The Web Prerequisites Basic understanding of python language. Basic familiarity with flask framework. What to expect from this course This course is divided into two high level parts. In the first part, assuming familiarity with python language\u2019s basic operations and syntax usage, we will dive a little deeper into understanding python as a language. We will compare python with other programming languages that you might already know like Java and C. We will also explore concepts of Python objects and with help of that, explore python features like decorators. In the second part which will revolve around the web, and also assume familiarity with the Flask framework, we will start from the socket module and work with HTTP requests. This will demystify how frameworks like flask work internally. And to introduce SRE flavour to the course, we will design, develop and deploy (in theory) a URL shortening application. We will emphasize parts of the whole process that are more important as an SRE of the said app/service. What is not covered under this course Extensive knowledge of python internals and advanced python. Lab Environment Setup Have latest version of python installed Course Contents The Python Language Some Python Concepts Python Gotchas Python and Web Sockets Flask The URL Shortening App Design Scaling The App Monitoring The App The Python Language Assuming you know a little bit of C/C++ and Java, let's try to discuss the following questions in context of those two languages and python. You might have heard that C/C++ is a compiled language while python is an interpreted language. Generally, with compiled language we first compile the program and then run the executable while in case of python we run the source code directly like python hello_world.py . While Java, being an interpreted language, still has a separate compilation step and then its run. So what's really the difference? Compiled vs. Interpreted This might sound a little weird to you: python, in a way is a compiled language! Python has a compiler built-in! It is obvious in the case of java since we compile it using a separate command ie: javac helloWorld.java and it will produce a .class file which we know as a bytecode . Well, python is very similar to that. One difference here is that there is no separate compile command/binary needed to run a python program. What is the difference then, between java and python? Well, Java's compiler is more strict and sophisticated. As you might know Java is a statically typed language. So the compiler is written in a way that it can verify types related errors during compile time. While python being a dynamic language, types are not known until a program is run. So in a way, python compiler is dumb (or, less strict). But there indeed is a compile step involved when a python program is run. You might have seen python bytecode files with .pyc extension. Here is how you can see bytecode for a given python program. # Create a Hello World $ echo \"print('hello world')\" > hello_world.py # Making sure it runs $ python3 hello_world.py hello world # The bytecode of the given program $ python -m dis hello_world.py 1 0 LOAD_NAME 0 (print) 2 LOAD_CONST 0 ('hello world') 4 CALL_FUNCTION 1 6 POP_TOP 8 LOAD_CONST 1 (None) 10 RETURN_VALUE Read more about dis module here Now coming to C/C++, there of course is a compiler. But the output is different than what java/python compiler would produce. Compiling a C program would produce what we also know as machine code . As opposed to bytecode. Running The Programs We know compilation is involved in all 3 languages we are discussing. Just that the compilers are different in nature and they output different types of content. In case of C/C++, the output is machine code which can be directly read by your operating system. When you execute that program, your OS will know how exactly to run it. But this is not the case with bytecode. Those bytecodes are language specific. Python has its own set of bytecode defined (more in dis module) and so does java. So naturally, your operating system will not know how to run it. To run this bytecode, we have something called Virtual Machines. Ie: The JVM or the Python VM (CPython, Jython). These so called Virtual Machines are the programs which can read the bytecode and run it on a given operating system. Python has multiple VMs available. Cpython is a python VM implemented in C language, similarly Jython is a Java implementation of python VM. At the end of the day, what they should be capable of is to understand python language syntax, be able to compile it to bytecode and be able to run that bytecode. You can implement a python VM in any language! (And people do so, just because it can be done) The Operating System +------------------------------------+ | | | | | | hello_world.py Python bytecode | Python VM Process | | | +----------------+ +----------------+ | +----------------+ | |print(... | COMPILE |LOAD_CONST... | | |Reads bytecode | | | +--------------->+ +------------------->+line by line | | | | | | | |and executes. | | | | | | | | | | +----------------+ +----------------+ | +----------------+ | | | | | | | hello_world.c OS Specific machinecode | A New Process | | | +----------------+ +----------------+ | +----------------+ | |void main() { | COMPILE | binary contents| | | binary contents| | | +--------------->+ +------------------->+ | | | | | | | | | | | | | | | | | | +----------------+ +----------------+ | +----------------+ | | (binary contents | | runs as is) | | | | | +------------------------------------+ Two things to note for above diagram: Generally, when we run a python program, a python VM process is started which reads the python source code, compiles it to byte code and run it in a single step. Compiling is not a separate step. Shown only for illustration purpose. Binaries generated for C like languages are not exactly run as is. Since there are multiple types of binaries (eg: ELF), there are more complicated steps involved in order to run a binary but we will not go into that since all that is done at OS level.","title":"Introduction"},{"location":"level101/python_web/intro/#python-and-the-web","text":"","title":"Python and The Web"},{"location":"level101/python_web/intro/#prerequisites","text":"Basic understanding of python language. Basic familiarity with flask framework.","title":"Prerequisites"},{"location":"level101/python_web/intro/#what-to-expect-from-this-course","text":"This course is divided into two high level parts. In the first part, assuming familiarity with python language\u2019s basic operations and syntax usage, we will dive a little deeper into understanding python as a language. We will compare python with other programming languages that you might already know like Java and C. We will also explore concepts of Python objects and with help of that, explore python features like decorators. In the second part which will revolve around the web, and also assume familiarity with the Flask framework, we will start from the socket module and work with HTTP requests. This will demystify how frameworks like flask work internally. And to introduce SRE flavour to the course, we will design, develop and deploy (in theory) a URL shortening application. We will emphasize parts of the whole process that are more important as an SRE of the said app/service.","title":"What to expect from this course"},{"location":"level101/python_web/intro/#what-is-not-covered-under-this-course","text":"Extensive knowledge of python internals and advanced python.","title":"What is not covered under this course"},{"location":"level101/python_web/intro/#lab-environment-setup","text":"Have latest version of python installed","title":"Lab Environment Setup"},{"location":"level101/python_web/intro/#course-contents","text":"The Python Language Some Python Concepts Python Gotchas Python and Web Sockets Flask The URL Shortening App Design Scaling The App Monitoring The App","title":"Course Contents"},{"location":"level101/python_web/intro/#the-python-language","text":"Assuming you know a little bit of C/C++ and Java, let's try to discuss the following questions in context of those two languages and python. You might have heard that C/C++ is a compiled language while python is an interpreted language. Generally, with compiled language we first compile the program and then run the executable while in case of python we run the source code directly like python hello_world.py . While Java, being an interpreted language, still has a separate compilation step and then its run. So what's really the difference?","title":"The Python Language"},{"location":"level101/python_web/intro/#compiled-vs-interpreted","text":"This might sound a little weird to you: python, in a way is a compiled language! Python has a compiler built-in! It is obvious in the case of java since we compile it using a separate command ie: javac helloWorld.java and it will produce a .class file which we know as a bytecode . Well, python is very similar to that. One difference here is that there is no separate compile command/binary needed to run a python program. What is the difference then, between java and python? Well, Java's compiler is more strict and sophisticated. As you might know Java is a statically typed language. So the compiler is written in a way that it can verify types related errors during compile time. While python being a dynamic language, types are not known until a program is run. So in a way, python compiler is dumb (or, less strict). But there indeed is a compile step involved when a python program is run. You might have seen python bytecode files with .pyc extension. Here is how you can see bytecode for a given python program. # Create a Hello World $ echo \"print('hello world')\" > hello_world.py # Making sure it runs $ python3 hello_world.py hello world # The bytecode of the given program $ python -m dis hello_world.py 1 0 LOAD_NAME 0 (print) 2 LOAD_CONST 0 ('hello world') 4 CALL_FUNCTION 1 6 POP_TOP 8 LOAD_CONST 1 (None) 10 RETURN_VALUE Read more about dis module here Now coming to C/C++, there of course is a compiler. But the output is different than what java/python compiler would produce. Compiling a C program would produce what we also know as machine code . As opposed to bytecode.","title":"Compiled vs. Interpreted"},{"location":"level101/python_web/intro/#running-the-programs","text":"We know compilation is involved in all 3 languages we are discussing. Just that the compilers are different in nature and they output different types of content. In case of C/C++, the output is machine code which can be directly read by your operating system. When you execute that program, your OS will know how exactly to run it. But this is not the case with bytecode. Those bytecodes are language specific. Python has its own set of bytecode defined (more in dis module) and so does java. So naturally, your operating system will not know how to run it. To run this bytecode, we have something called Virtual Machines. Ie: The JVM or the Python VM (CPython, Jython). These so called Virtual Machines are the programs which can read the bytecode and run it on a given operating system. Python has multiple VMs available. Cpython is a python VM implemented in C language, similarly Jython is a Java implementation of python VM. At the end of the day, what they should be capable of is to understand python language syntax, be able to compile it to bytecode and be able to run that bytecode. You can implement a python VM in any language! (And people do so, just because it can be done) The Operating System +------------------------------------+ | | | | | | hello_world.py Python bytecode | Python VM Process | | | +----------------+ +----------------+ | +----------------+ | |print(... | COMPILE |LOAD_CONST... | | |Reads bytecode | | | +--------------->+ +------------------->+line by line | | | | | | | |and executes. | | | | | | | | | | +----------------+ +----------------+ | +----------------+ | | | | | | | hello_world.c OS Specific machinecode | A New Process | | | +----------------+ +----------------+ | +----------------+ | |void main() { | COMPILE | binary contents| | | binary contents| | | +--------------->+ +------------------->+ | | | | | | | | | | | | | | | | | | +----------------+ +----------------+ | +----------------+ | | (binary contents | | runs as is) | | | | | +------------------------------------+ Two things to note for above diagram: Generally, when we run a python program, a python VM process is started which reads the python source code, compiles it to byte code and run it in a single step. Compiling is not a separate step. Shown only for illustration purpose. Binaries generated for C like languages are not exactly run as is. Since there are multiple types of binaries (eg: ELF), there are more complicated steps involved in order to run a binary but we will not go into that since all that is done at OS level.","title":"Running The Programs"},{"location":"level101/python_web/python-concepts/","text":"Some Python Concepts Though you are expected to know python and its syntax at basic level, let us discuss some fundamental concepts that will help you understand the python language better. Everything in Python is an object. That includes the functions, lists, dicts, classes, modules, a running function (instance of function definition), everything. In the CPython, it would mean there is an underlying struct variable for each object. In python's current execution context, all the variables are stored in a dict. It'd be a string to object mapping. If you have a function and a float variable defined in the current context, here is how it is handled internally. >>> float_number=42.0 >>> def foo_func(): ... pass ... # NOTICE HOW VARIABLE NAMES ARE STRINGS, stored in a dict >>> locals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'float_number': 42.0, 'foo_func': } Python Functions Since functions too are objects, we can see what all attributes a function contains as following >>> def hello(name): ... print(f\"Hello, {name}!\") ... >>> dir(hello) ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'] While there are a lot of them, let's look at some interesting ones globals This attribute, as the name suggests, has references of global variables. If you ever need to know what all global variables are in the scope of this function, this will tell you. See how the function start seeing the new variable in globals >>> hello.__globals__ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'hello': } # adding new global variable >>> GLOBAL=\"g_val\" >>> hello.__globals__ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'hello': , 'GLOBAL': 'g_val'} code This is an interesting one! As everything in python is an object, this includes the bytecode too. The compiled python bytecode is a python code object. Which is accessible via __code__ attribute here. A function has an associated code object which carries some interesting information. # the file in which function is defined # stdin here since this is run in an interpreter >>> hello.__code__.co_filename '' # number of arguments the function takes >>> hello.__code__.co_argcount 1 # local variable names >>> hello.__code__.co_varnames ('name',) # the function code's compiled bytecode >>> hello.__code__.co_code b't\\x00d\\x01|\\x00\\x9b\\x00d\\x02\\x9d\\x03\\x83\\x01\\x01\\x00d\\x00S\\x00' There are more code attributes which you can enlist by >>> dir(hello.__code__) Decorators Related to functions, python has another feature called decorators. Let's see how that works, keeping everything is an object in mind. Here is a sample decorator: >>> def deco(func): ... def inner(): ... print(\"before\") ... func() ... print(\"after\") ... return inner ... >>> @deco ... def hello_world(): ... print(\"hello world\") ... >>> >>> hello_world() before hello world after Here @deco syntax is used to decorate the hello_world function. It is essentially same as doing >>> def hello_world(): ... print(\"hello world\") ... >>> hello_world = deco(hello_world) What goes inside the deco function might seem complex. Let's try to uncover it. Function hello_world is created It is passed to deco function deco create a new function This new function is calls hello_world function And does a couple other things deco returns the newly created function hello_world is replaced with above function Let's visualize it for better understanding BEFORE function_object (ID: 100) \"hello_world\" +--------------------+ + |print(\"hello_world\")| | | | +--------------> | | | | +--------------------+ WHAT DECORATOR DOES creates a new function (ID: 101) +---------------------------------+ |input arg: function with id: 100 | | | |print(\"before\") | |call function object with id 100 | |print(\"after\") | | | +---------------------------------+ ^ | AFTER | | | \"hello_world\" +-------------+ Note how the hello_world name points to a new function object but that new function object knows the reference (ID) of the original function. Some Gotchas While it is very quick to build prototypes in python and there are tons of libraries available, as the codebase complexity increases, type errors become more common and will get hard to deal with. (There are solutions to that problem like type annotations in python. Checkout mypy .) Because python is dynamically typed language, that means all types are determined at runtime. And that makes python run very slow compared to other statically typed languages. Python has something called GIL (global interpreter lock) which is a limiting factor for utilizing multiple CPU cores for parallel computation. Some weird things that python does: https://github.com/satwikkansal/wtfpython","title":"Some Python Concepts"},{"location":"level101/python_web/python-concepts/#some-python-concepts","text":"Though you are expected to know python and its syntax at basic level, let us discuss some fundamental concepts that will help you understand the python language better. Everything in Python is an object. That includes the functions, lists, dicts, classes, modules, a running function (instance of function definition), everything. In the CPython, it would mean there is an underlying struct variable for each object. In python's current execution context, all the variables are stored in a dict. It'd be a string to object mapping. If you have a function and a float variable defined in the current context, here is how it is handled internally. >>> float_number=42.0 >>> def foo_func(): ... pass ... # NOTICE HOW VARIABLE NAMES ARE STRINGS, stored in a dict >>> locals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'float_number': 42.0, 'foo_func': }","title":"Some Python Concepts"},{"location":"level101/python_web/python-concepts/#python-functions","text":"Since functions too are objects, we can see what all attributes a function contains as following >>> def hello(name): ... print(f\"Hello, {name}!\") ... >>> dir(hello) ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'] While there are a lot of them, let's look at some interesting ones","title":"Python Functions"},{"location":"level101/python_web/python-concepts/#globals","text":"This attribute, as the name suggests, has references of global variables. If you ever need to know what all global variables are in the scope of this function, this will tell you. See how the function start seeing the new variable in globals >>> hello.__globals__ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'hello': } # adding new global variable >>> GLOBAL=\"g_val\" >>> hello.__globals__ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'hello': , 'GLOBAL': 'g_val'}","title":"globals"},{"location":"level101/python_web/python-concepts/#code","text":"This is an interesting one! As everything in python is an object, this includes the bytecode too. The compiled python bytecode is a python code object. Which is accessible via __code__ attribute here. A function has an associated code object which carries some interesting information. # the file in which function is defined # stdin here since this is run in an interpreter >>> hello.__code__.co_filename '' # number of arguments the function takes >>> hello.__code__.co_argcount 1 # local variable names >>> hello.__code__.co_varnames ('name',) # the function code's compiled bytecode >>> hello.__code__.co_code b't\\x00d\\x01|\\x00\\x9b\\x00d\\x02\\x9d\\x03\\x83\\x01\\x01\\x00d\\x00S\\x00' There are more code attributes which you can enlist by >>> dir(hello.__code__)","title":"code"},{"location":"level101/python_web/python-concepts/#decorators","text":"Related to functions, python has another feature called decorators. Let's see how that works, keeping everything is an object in mind. Here is a sample decorator: >>> def deco(func): ... def inner(): ... print(\"before\") ... func() ... print(\"after\") ... return inner ... >>> @deco ... def hello_world(): ... print(\"hello world\") ... >>> >>> hello_world() before hello world after Here @deco syntax is used to decorate the hello_world function. It is essentially same as doing >>> def hello_world(): ... print(\"hello world\") ... >>> hello_world = deco(hello_world) What goes inside the deco function might seem complex. Let's try to uncover it. Function hello_world is created It is passed to deco function deco create a new function This new function is calls hello_world function And does a couple other things deco returns the newly created function hello_world is replaced with above function Let's visualize it for better understanding BEFORE function_object (ID: 100) \"hello_world\" +--------------------+ + |print(\"hello_world\")| | | | +--------------> | | | | +--------------------+ WHAT DECORATOR DOES creates a new function (ID: 101) +---------------------------------+ |input arg: function with id: 100 | | | |print(\"before\") | |call function object with id 100 | |print(\"after\") | | | +---------------------------------+ ^ | AFTER | | | \"hello_world\" +-------------+ Note how the hello_world name points to a new function object but that new function object knows the reference (ID) of the original function.","title":"Decorators"},{"location":"level101/python_web/python-concepts/#some-gotchas","text":"While it is very quick to build prototypes in python and there are tons of libraries available, as the codebase complexity increases, type errors become more common and will get hard to deal with. (There are solutions to that problem like type annotations in python. Checkout mypy .) Because python is dynamically typed language, that means all types are determined at runtime. And that makes python run very slow compared to other statically typed languages. Python has something called GIL (global interpreter lock) which is a limiting factor for utilizing multiple CPU cores for parallel computation. Some weird things that python does: https://github.com/satwikkansal/wtfpython","title":"Some Gotchas"},{"location":"level101/python_web/python-web-flask/","text":"Python, Web and Flask Back in the old days, websites were simple. They were simple static html contents. A webserver would be listening on a defined port and according to the HTTP request received, it would read files from disk and return them in response. But since then, complexity has evolved and websites are now dynamic. Depending on the request, multiple operations need to be performed like reading from database or calling other API and finally returning some response (HTML data, JSON content etc.) Since serving web requests is no longer a simple task like reading files from disk and return contents, we need to process each http request, perform some operations programmatically and construct a response. Sockets Though we have frameworks like flask, HTTP is still a protocol that works over TCP protocol. So let us setup a TCP server and send an HTTP request and inspect the request's payload. Note that this is not a tutorial on socket programming but what we are doing here is inspecting HTTP protocol at its ground level and look at what its contents look like. (Ref: Socket Programming in Python (Guide) on RealPython ) import socket HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() conn, addr = s.accept() with conn: print('Connected by', addr) while True: data = conn.recv(1024) if not data: break print(data) Then we open localhost:65432 in our web browser and following would be the output: Connected by ('127.0.0.1', 54719) b'GET / HTTP/1.1\\r\\nHost: localhost:65432\\r\\nConnection: keep-alive\\r\\nDNT: 1\\r\\nUpgrade-Insecure-Requests: 1\\r\\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36 Edg/85.0.564.44\\r\\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\\r\\nSec-Fetch-Site: none\\r\\nSec-Fetch-Mode: navigate\\r\\nSec-Fetch-User: ?1\\r\\nSec-Fetch-Dest: document\\r\\nAccept-Encoding: gzip, deflate, br\\r\\nAccept-Language: en-US,en;q=0.9\\r\\n\\r\\n' Examine closely and the content will look like the HTTP protocol's format. ie: HTTP_METHOD URI_PATH HTTP_VERSION HEADERS_SEPARATED_BY_SEPARATOR So though it's a blob of bytes, knowing http protocol specification , you can parse that string (ie: split by \\r\\n ) and get meaningful information out of it. Flask Flask, and other such frameworks does pretty much what we just discussed in the last section (with added more sophistication). They listen on a port on a TCP socket, receive an HTTP request, parse the data according to protocol format and make it available to you in a convenient manner. ie: you can access headers in flask by request.headers which is made available to you by splitting above payload by /r/n , as defined in http protocol. Another example: we register routes in flask by @app.route(\"/hello\") . What flask will do is maintain a registry internally which will map /hello with the function you decorated with. Now whenever a request comes with the /hello route (second component in the first line, split by space), flask calls the registered function and returns whatever the function returned. Same with all other web frameworks in other languages too. They all work on similar principles. What they basically do is understand the HTTP protocol, parses the HTTP request data and gives us programmers a nice interface to work with HTTP requests. Not so much of magic, innit?","title":"Python, Web and Flask"},{"location":"level101/python_web/python-web-flask/#python-web-and-flask","text":"Back in the old days, websites were simple. They were simple static html contents. A webserver would be listening on a defined port and according to the HTTP request received, it would read files from disk and return them in response. But since then, complexity has evolved and websites are now dynamic. Depending on the request, multiple operations need to be performed like reading from database or calling other API and finally returning some response (HTML data, JSON content etc.) Since serving web requests is no longer a simple task like reading files from disk and return contents, we need to process each http request, perform some operations programmatically and construct a response.","title":"Python, Web and Flask"},{"location":"level101/python_web/python-web-flask/#sockets","text":"Though we have frameworks like flask, HTTP is still a protocol that works over TCP protocol. So let us setup a TCP server and send an HTTP request and inspect the request's payload. Note that this is not a tutorial on socket programming but what we are doing here is inspecting HTTP protocol at its ground level and look at what its contents look like. (Ref: Socket Programming in Python (Guide) on RealPython ) import socket HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() conn, addr = s.accept() with conn: print('Connected by', addr) while True: data = conn.recv(1024) if not data: break print(data) Then we open localhost:65432 in our web browser and following would be the output: Connected by ('127.0.0.1', 54719) b'GET / HTTP/1.1\\r\\nHost: localhost:65432\\r\\nConnection: keep-alive\\r\\nDNT: 1\\r\\nUpgrade-Insecure-Requests: 1\\r\\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36 Edg/85.0.564.44\\r\\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\\r\\nSec-Fetch-Site: none\\r\\nSec-Fetch-Mode: navigate\\r\\nSec-Fetch-User: ?1\\r\\nSec-Fetch-Dest: document\\r\\nAccept-Encoding: gzip, deflate, br\\r\\nAccept-Language: en-US,en;q=0.9\\r\\n\\r\\n' Examine closely and the content will look like the HTTP protocol's format. ie: HTTP_METHOD URI_PATH HTTP_VERSION HEADERS_SEPARATED_BY_SEPARATOR So though it's a blob of bytes, knowing http protocol specification , you can parse that string (ie: split by \\r\\n ) and get meaningful information out of it.","title":"Sockets"},{"location":"level101/python_web/python-web-flask/#flask","text":"Flask, and other such frameworks does pretty much what we just discussed in the last section (with added more sophistication). They listen on a port on a TCP socket, receive an HTTP request, parse the data according to protocol format and make it available to you in a convenient manner. ie: you can access headers in flask by request.headers which is made available to you by splitting above payload by /r/n , as defined in http protocol. Another example: we register routes in flask by @app.route(\"/hello\") . What flask will do is maintain a registry internally which will map /hello with the function you decorated with. Now whenever a request comes with the /hello route (second component in the first line, split by space), flask calls the registered function and returns whatever the function returned. Same with all other web frameworks in other languages too. They all work on similar principles. What they basically do is understand the HTTP protocol, parses the HTTP request data and gives us programmers a nice interface to work with HTTP requests. Not so much of magic, innit?","title":"Flask"},{"location":"level101/python_web/sre-conclusion/","text":"Conclusion Scaling The App The design and development is just a part of the journey. We will need to setup continuous integration and continuous delivery pipelines sooner or later. And we have to deploy this app somewhere. Initially we can start with deploying this app on one virtual machine on any cloud provider. But this is a Single point of failure which is something we never allow as an SRE (or even as an engineer). So an improvement here can be having multiple instances of applications deployed behind a load balancer. This certainly prevents problems of one machine going down. Scaling here would mean adding more instances behind the load balancer. But this is scalable upto only a certain point. After that, other bottlenecks in the system will start appearing. ie: DB will become the bottleneck, or perhaps the load balancer itself. How do you know what is the bottleneck? You need to have observability into each aspects of the application architecture. Only after you have metrics, you will be able to know what is going wrong where. What gets measured, gets fixed! Get deeper insights into scaling from School Of SRE's Scalability module and post going through it, apply your learnings and takeaways to this app. Think how will we make this app geographically distributed and highly available and scalable. Monitoring Strategy Once we have our application deployed. It will be working ok. But not forever. Reliability is in the title of our job and we make systems reliable by making the design in a certain way. But things still will go down. Machines will fail. Disks will behave weirdly. Buggy code will get pushed to production. And all these possible scenarios will make the system less reliable. So what do we do? We monitor! We keep an eye on the system's health and if anything is not going as expected, we want ourselves to get alerted. Now let's think in terms of the given url shortening app. We need to monitor it. And we would want to get notified in case something goes wrong. But we first need to decide what is that something that we want to keep an eye on. Since it's a web app serving HTTP requests, we want to keep an eye on HTTP Status codes and latencies Request volume again is a good candidate, if the app is receiving an unusual amount of traffic, something might be off. We also want to keep an eye on the database so depending on the database solution chosen. Query times, volumes, disk usage etc. Finally, there also needs to be some external monitoring which runs periodic tests from devices outside of your data centers. This emulates customers and ensures that from customer point of view, the system is working as expected. Applications in SRE role In the world of SRE, python is a widely used language. For small scripts and tooling developed for various purposes. Since tooling developed by SRE works with critical pieces of infrastructure and has great power (to bring things down), it is important to know what you are doing while using a programming language and its features. Also it is equally important to know the language and its characteristics while debugging the issues. As an SRE having a deeper understanding of python language, it has helped me a lot to debug very sneaky bugs and be generally more aware and informed while making certain design decisions. While developing tools may or may not be part of SRE job, supporting tools or services is more likely to be a daily duty. Building an application or tool is just a small part of productionization. While there is certainly that goes in the design of the application itself to make it more robust, as an SRE you are responsible for its reliability and stability once it is deployed and running. And to ensure that, you\u2019d need to understand the application first and then come up with a strategy to monitor it properly and be prepared for various failure scenarios. Optional Exercises Make a decorator that will cache function return values depending on input parameters. Host the URL shortening app on any cloud provider. Setup monitoring using many of the tools available like catchpoint, datadog etc. Create a minimal flask-like framework on top of TCP sockets. Conclusion This module, in the first part, aims to make you more aware of the things that will happen when you choose python as your programming language and what happens when you run a python program. With the knowledge of how python handles things internally as objects, lot of seemingly magic things in python will start to make more sense. The second part will first explain how a framework like flask works using the existing knowledge of protocols like TCP and HTTP. It then touches the whole lifecycle of an application development lifecycle including the SRE parts of it. While the design and areas in architecture considered will not be exhaustive, it will give a good overview of things that are also important being an SRE and why they are important.","title":"Conclusion"},{"location":"level101/python_web/sre-conclusion/#conclusion","text":"","title":"Conclusion"},{"location":"level101/python_web/sre-conclusion/#scaling-the-app","text":"The design and development is just a part of the journey. We will need to setup continuous integration and continuous delivery pipelines sooner or later. And we have to deploy this app somewhere. Initially we can start with deploying this app on one virtual machine on any cloud provider. But this is a Single point of failure which is something we never allow as an SRE (or even as an engineer). So an improvement here can be having multiple instances of applications deployed behind a load balancer. This certainly prevents problems of one machine going down. Scaling here would mean adding more instances behind the load balancer. But this is scalable upto only a certain point. After that, other bottlenecks in the system will start appearing. ie: DB will become the bottleneck, or perhaps the load balancer itself. How do you know what is the bottleneck? You need to have observability into each aspects of the application architecture. Only after you have metrics, you will be able to know what is going wrong where. What gets measured, gets fixed! Get deeper insights into scaling from School Of SRE's Scalability module and post going through it, apply your learnings and takeaways to this app. Think how will we make this app geographically distributed and highly available and scalable.","title":"Scaling The App"},{"location":"level101/python_web/sre-conclusion/#monitoring-strategy","text":"Once we have our application deployed. It will be working ok. But not forever. Reliability is in the title of our job and we make systems reliable by making the design in a certain way. But things still will go down. Machines will fail. Disks will behave weirdly. Buggy code will get pushed to production. And all these possible scenarios will make the system less reliable. So what do we do? We monitor! We keep an eye on the system's health and if anything is not going as expected, we want ourselves to get alerted. Now let's think in terms of the given url shortening app. We need to monitor it. And we would want to get notified in case something goes wrong. But we first need to decide what is that something that we want to keep an eye on. Since it's a web app serving HTTP requests, we want to keep an eye on HTTP Status codes and latencies Request volume again is a good candidate, if the app is receiving an unusual amount of traffic, something might be off. We also want to keep an eye on the database so depending on the database solution chosen. Query times, volumes, disk usage etc. Finally, there also needs to be some external monitoring which runs periodic tests from devices outside of your data centers. This emulates customers and ensures that from customer point of view, the system is working as expected.","title":"Monitoring Strategy"},{"location":"level101/python_web/sre-conclusion/#applications-in-sre-role","text":"In the world of SRE, python is a widely used language. For small scripts and tooling developed for various purposes. Since tooling developed by SRE works with critical pieces of infrastructure and has great power (to bring things down), it is important to know what you are doing while using a programming language and its features. Also it is equally important to know the language and its characteristics while debugging the issues. As an SRE having a deeper understanding of python language, it has helped me a lot to debug very sneaky bugs and be generally more aware and informed while making certain design decisions. While developing tools may or may not be part of SRE job, supporting tools or services is more likely to be a daily duty. Building an application or tool is just a small part of productionization. While there is certainly that goes in the design of the application itself to make it more robust, as an SRE you are responsible for its reliability and stability once it is deployed and running. And to ensure that, you\u2019d need to understand the application first and then come up with a strategy to monitor it properly and be prepared for various failure scenarios.","title":"Applications in SRE role"},{"location":"level101/python_web/sre-conclusion/#optional-exercises","text":"Make a decorator that will cache function return values depending on input parameters. Host the URL shortening app on any cloud provider. Setup monitoring using many of the tools available like catchpoint, datadog etc. Create a minimal flask-like framework on top of TCP sockets.","title":"Optional Exercises"},{"location":"level101/python_web/sre-conclusion/#conclusion_1","text":"This module, in the first part, aims to make you more aware of the things that will happen when you choose python as your programming language and what happens when you run a python program. With the knowledge of how python handles things internally as objects, lot of seemingly magic things in python will start to make more sense. The second part will first explain how a framework like flask works using the existing knowledge of protocols like TCP and HTTP. It then touches the whole lifecycle of an application development lifecycle including the SRE parts of it. While the design and areas in architecture considered will not be exhaustive, it will give a good overview of things that are also important being an SRE and why they are important.","title":"Conclusion"},{"location":"level101/python_web/url-shorten-app/","text":"The URL Shortening App Let's build a very simple URL shortening app using flask and try to incorporate all aspects of the development process including the reliability aspects. We will not be building the UI and we will come up with a minimal set of API that will be enough for the app to function well. Design We don't jump directly to coding. First thing we do is gather requirements. Come up with an approach. Have the approach/design reviewed by peers. Evolve, iterate, document the decisions and tradeoffs. And then finally implement. While we will not do the full blown design document here, we will raise certain questions here that are important to the design. 1. High Level Operations and API Endpoints Since it's a URL shortening app, we will need an API for generating the shorten link given an original link. And an API/Endpoint which will accept the shorten link and redirect to original URL. We are not including the user aspect of the app to keep things minimal. These two API should make app functional and usable by anyone. 2. How to shorten? Given a url, we will need to generate a shortened version of it. One approach could be using random characters for each link. Another thing that can be done is to use some sort of hashing algorithm. The benefit here is we will reuse the same hash for the same link. ie: if lot of people are shortening https://www.linkedin.com they all will have the same value, compared to multiple entries in DB if chosen random characters. What about hash collisions? Even in random characters approach, though there is a less probability, hash collisions can happen. And we need to be mindful of them. In that case we might want to prepend/append the string with some random value to avoid conflict. Also, choice of hash algorithm matters. We will need to analyze algorithms. Their CPU requirements and their characteristics. Choose one that suits the most. 3. Is URL Valid? Given a URL to shorten, how do we verify if the URL is valid? Do we even verify or validate? One basic check that can be done is see if the URL matches a regex of a URL. To go even further we can try opening/visiting the URL. But there are certain gotchas here. We need to define success criteria. ie: HTTP 200 means it is valid. What is the URL is in private network? What if URL is temporarily down? 4. Storage Finally, storage. Where will we store the data that we will generate over time? There are multiple database solutions available and we will need to choose the one that suits this app the most. Relational database like MySQL would be a fair choice but be sure to checkout School of SRE's SQL database section and NoSQL databases section for deeper insights into making a more informed decision. 5. Other We are not accounting for users into our app and other possible features like rate limiting, customized links etc but it will eventually come up with time. Depending on the requirements, they too might need to get incorporated. The minimal working code is given below for reference but I'd encourage you to come up with your own. from flask import Flask, redirect, request from hashlib import md5 app = Flask(\"url_shortener\") mapping = {} @app.route(\"/shorten\", methods=[\"POST\"]) def shorten(): global mapping payload = request.json if \"url\" not in payload: return \"Missing URL Parameter\", 400 # TODO: check if URL is valid hash_ = md5() hash_.update(payload[\"url\"].encode()) digest = hash_.hexdigest()[:5] # limiting to 5 chars. Less the limit more the chances of collission if digest not in mapping: mapping[digest] = payload[\"url\"] return f\"Shortened: r/{digest}\\n\" else: # TODO: check for hash collission return f\"Already exists: r/{digest}\\n\" @app.route(\"/r/\") def redirect_(hash_): if hash_ not in mapping: return \"URL Not Found\", 404 return redirect(mapping[hash_]) if __name__ == \"__main__\": app.run(debug=True) \"\"\" OUTPUT: ===> SHORTENING $ curl localhost:5000/shorten -H \"content-type: application/json\" --data '{\"url\":\"https://linkedin.com\"}' Shortened: r/a62a4 ===> REDIRECTING, notice the response code 302 and the location header $ curl localhost:5000/r/a62a4 -v * Uses proxy env variable NO_PROXY == '127.0.0.1' * Trying ::1... * TCP_NODELAY set * Connection failed * connect to ::1 port 5000 failed: Connection refused * Trying 127.0.0.1... * TCP_NODELAY set * Connected to localhost (127.0.0.1) port 5000 (#0) > GET /r/a62a4 HTTP/1.1 > Host: localhost:5000 > User-Agent: curl/7.64.1 > Accept: */* > * HTTP 1.0, assume close after body < HTTP/1.0 302 FOUND < Content-Type: text/html; charset=utf-8 < Content-Length: 247 < Location: https://linkedin.com < Server: Werkzeug/0.15.4 Python/3.7.7 < Date: Tue, 27 Oct 2020 09:37:12 GMT < Redirecting...

    Redirecting...

    * Closing connection 0

    You should be redirected automatically to target URL: https://linkedin.com. If not click the link. \"\"\"","title":"The URL Shortening App"},{"location":"level101/python_web/url-shorten-app/#the-url-shortening-app","text":"Let's build a very simple URL shortening app using flask and try to incorporate all aspects of the development process including the reliability aspects. We will not be building the UI and we will come up with a minimal set of API that will be enough for the app to function well.","title":"The URL Shortening App"},{"location":"level101/python_web/url-shorten-app/#design","text":"We don't jump directly to coding. First thing we do is gather requirements. Come up with an approach. Have the approach/design reviewed by peers. Evolve, iterate, document the decisions and tradeoffs. And then finally implement. While we will not do the full blown design document here, we will raise certain questions here that are important to the design.","title":"Design"},{"location":"level101/python_web/url-shorten-app/#1-high-level-operations-and-api-endpoints","text":"Since it's a URL shortening app, we will need an API for generating the shorten link given an original link. And an API/Endpoint which will accept the shorten link and redirect to original URL. We are not including the user aspect of the app to keep things minimal. These two API should make app functional and usable by anyone.","title":"1. High Level Operations and API Endpoints"},{"location":"level101/python_web/url-shorten-app/#2-how-to-shorten","text":"Given a url, we will need to generate a shortened version of it. One approach could be using random characters for each link. Another thing that can be done is to use some sort of hashing algorithm. The benefit here is we will reuse the same hash for the same link. ie: if lot of people are shortening https://www.linkedin.com they all will have the same value, compared to multiple entries in DB if chosen random characters. What about hash collisions? Even in random characters approach, though there is a less probability, hash collisions can happen. And we need to be mindful of them. In that case we might want to prepend/append the string with some random value to avoid conflict. Also, choice of hash algorithm matters. We will need to analyze algorithms. Their CPU requirements and their characteristics. Choose one that suits the most.","title":"2. How to shorten?"},{"location":"level101/python_web/url-shorten-app/#3-is-url-valid","text":"Given a URL to shorten, how do we verify if the URL is valid? Do we even verify or validate? One basic check that can be done is see if the URL matches a regex of a URL. To go even further we can try opening/visiting the URL. But there are certain gotchas here. We need to define success criteria. ie: HTTP 200 means it is valid. What is the URL is in private network? What if URL is temporarily down?","title":"3. Is URL Valid?"},{"location":"level101/python_web/url-shorten-app/#4-storage","text":"Finally, storage. Where will we store the data that we will generate over time? There are multiple database solutions available and we will need to choose the one that suits this app the most. Relational database like MySQL would be a fair choice but be sure to checkout School of SRE's SQL database section and NoSQL databases section for deeper insights into making a more informed decision.","title":"4. Storage"},{"location":"level101/python_web/url-shorten-app/#5-other","text":"We are not accounting for users into our app and other possible features like rate limiting, customized links etc but it will eventually come up with time. Depending on the requirements, they too might need to get incorporated. The minimal working code is given below for reference but I'd encourage you to come up with your own. from flask import Flask, redirect, request from hashlib import md5 app = Flask(\"url_shortener\") mapping = {} @app.route(\"/shorten\", methods=[\"POST\"]) def shorten(): global mapping payload = request.json if \"url\" not in payload: return \"Missing URL Parameter\", 400 # TODO: check if URL is valid hash_ = md5() hash_.update(payload[\"url\"].encode()) digest = hash_.hexdigest()[:5] # limiting to 5 chars. Less the limit more the chances of collission if digest not in mapping: mapping[digest] = payload[\"url\"] return f\"Shortened: r/{digest}\\n\" else: # TODO: check for hash collission return f\"Already exists: r/{digest}\\n\" @app.route(\"/r/\") def redirect_(hash_): if hash_ not in mapping: return \"URL Not Found\", 404 return redirect(mapping[hash_]) if __name__ == \"__main__\": app.run(debug=True) \"\"\" OUTPUT: ===> SHORTENING $ curl localhost:5000/shorten -H \"content-type: application/json\" --data '{\"url\":\"https://linkedin.com\"}' Shortened: r/a62a4 ===> REDIRECTING, notice the response code 302 and the location header $ curl localhost:5000/r/a62a4 -v * Uses proxy env variable NO_PROXY == '127.0.0.1' * Trying ::1... * TCP_NODELAY set * Connection failed * connect to ::1 port 5000 failed: Connection refused * Trying 127.0.0.1... * TCP_NODELAY set * Connected to localhost (127.0.0.1) port 5000 (#0) > GET /r/a62a4 HTTP/1.1 > Host: localhost:5000 > User-Agent: curl/7.64.1 > Accept: */* > * HTTP 1.0, assume close after body < HTTP/1.0 302 FOUND < Content-Type: text/html; charset=utf-8 < Content-Length: 247 < Location: https://linkedin.com < Server: Werkzeug/0.15.4 Python/3.7.7 < Date: Tue, 27 Oct 2020 09:37:12 GMT < Redirecting...

    Redirecting...

    * Closing connection 0

    You should be redirected automatically to target URL: https://linkedin.com. If not click the link. \"\"\"","title":"5. Other"},{"location":"level101/security/conclusion/","text":"Conclusion Now that you have completed this course on Security you are now aware of the possible security threats to computer systems & networks. Not only that, but you are now better able to protect your systems as well as recommend security measures to others. This course provides fundamental everyday knowledge on security domain which will also help you keep security at the top of your priority. Other Resources Some books that would be a great resource Holistic Info-Sec for Web Developers https://holisticinfosecforwebdevelopers.com/ - Free and downloadable book series with very broad and deep coverage of what Web Developers and DevOps Engineers need to know in order to create robust, reliable, maintainable and secure software, networks and other, that are delivered continuously, on time, with no nasty surprises Docker Security - Quick Reference: For DevOps Engineers https://leanpub.com/dockersecurity-quickreference - A book on understanding the Docker security defaults, how to improve them (theory and practical), along with many tools and techniques. How to Hack Like a Legend https://amzn.to/2uWh1Up - A hacker\u2019s tale breaking into a secretive offshore company, Sparc Flow, 2018 How to Investigate Like a Rockstar https://books2read.com/u/4jDWoZ - Live a real crisis to master the secrets of forensic analysis, Sparc Flow, 2017 Real World Cryptography https://www.manning.com/books/real-world-cryptography - This early-access book teaches you applied cryptographic techniques to understand and apply security at every level of your systems and applications. AWS Security https://www.manning.com/books/aws-security?utm_source=github&utm_medium=organic&utm_campaign=book_shields_aws_1_31_20 - This early-access book covers commong AWS security issues and best practices for access policies, data protection, auditing, continuous monitoring, and incident response. Post Training asks/ Further Reading CTF Events like : https://github.com/apsdehal/awesome-ctf Penetration Testing : https://github.com/enaqx/awesome-pentest Threat Intelligence : https://github.com/hslatman/awesome-threat-intelligence Threat Detection & Hunting : https://github.com/0x4D31/awesome-threat-detection Web Security: https://github.com/qazbnm456/awesome-web-security Building Secure and Reliable Systems : https://landing.google.com/sre/resources/foundationsandprinciples/srs-book/","title":"Conclusion"},{"location":"level101/security/conclusion/#conclusion","text":"Now that you have completed this course on Security you are now aware of the possible security threats to computer systems & networks. Not only that, but you are now better able to protect your systems as well as recommend security measures to others. This course provides fundamental everyday knowledge on security domain which will also help you keep security at the top of your priority.","title":"Conclusion"},{"location":"level101/security/conclusion/#other-resources","text":"Some books that would be a great resource Holistic Info-Sec for Web Developers https://holisticinfosecforwebdevelopers.com/ - Free and downloadable book series with very broad and deep coverage of what Web Developers and DevOps Engineers need to know in order to create robust, reliable, maintainable and secure software, networks and other, that are delivered continuously, on time, with no nasty surprises Docker Security - Quick Reference: For DevOps Engineers https://leanpub.com/dockersecurity-quickreference - A book on understanding the Docker security defaults, how to improve them (theory and practical), along with many tools and techniques. How to Hack Like a Legend https://amzn.to/2uWh1Up - A hacker\u2019s tale breaking into a secretive offshore company, Sparc Flow, 2018 How to Investigate Like a Rockstar https://books2read.com/u/4jDWoZ - Live a real crisis to master the secrets of forensic analysis, Sparc Flow, 2017 Real World Cryptography https://www.manning.com/books/real-world-cryptography - This early-access book teaches you applied cryptographic techniques to understand and apply security at every level of your systems and applications. AWS Security https://www.manning.com/books/aws-security?utm_source=github&utm_medium=organic&utm_campaign=book_shields_aws_1_31_20 - This early-access book covers commong AWS security issues and best practices for access policies, data protection, auditing, continuous monitoring, and incident response.","title":"Other Resources"},{"location":"level101/security/conclusion/#post-training-asks-further-reading","text":"CTF Events like : https://github.com/apsdehal/awesome-ctf Penetration Testing : https://github.com/enaqx/awesome-pentest Threat Intelligence : https://github.com/hslatman/awesome-threat-intelligence Threat Detection & Hunting : https://github.com/0x4D31/awesome-threat-detection Web Security: https://github.com/qazbnm456/awesome-web-security Building Secure and Reliable Systems : https://landing.google.com/sre/resources/foundationsandprinciples/srs-book/","title":"Post Training asks/ Further Reading"},{"location":"level101/security/fundamentals/","text":"Part I: Fundamentals Introduction to Security Overview for SRE If you look closely, both Site Reliability Engineering and Security Engineering are concerned with keeping a system usable. Issues like broken releases, capacity shortages, and misconfigurations can make a system unusable (at least temporarily). Security or privacy incidents that break the trust of users also undermine the usefulness of a system. Consequently, system security should be top of mind for SREs. SREs should be involved in both significant design discussions and actual system changes. They have quite a big role in System design & hence are quite sometimes the first line of defence. SRE\u2019s help in preventing bad design & implementations which can affect the overall security of the infrastructure. Successfully designing, implementing, and maintaining systems requires a commitment to the full system lifecycle . This commitment is possible only when security and reliability are central elements in the architecture of systems. Core Pillars of Information Security : Confidentiality \u2013 only allow access to data for which the user is permitted Integrity \u2013 ensure data is not tampered or altered by unauthorized users Availability \u2013 ensure systems and data are available to authorized users when they need it Thinking like a Security Engineer When starting a new application or re-factoring an existing application, you should consider each functional feature, and consider: Is the process surrounding this feature as safe as possible? In other words, is this a flawed process? If I were evil, how would I abuse this feature? Or more specifically failing to address how a feature can be abused can cause design flaws. Is the feature required to be on by default? If so, are there limits or options that could help reduce the risk from this feature? Security Principles By OWASP (Open Web Application Security Project) Minimize attack surface area : Every feature that is added to an application adds a certain amount of risk to the overall application. The aim of secure development is to reduce the overall risk by reducing the attack surface area. For example, a web application implements online help with a search function. The search function may be vulnerable to SQL injection attacks. If the help feature was limited to authorized users, the attack likelihood is reduced. If the help feature\u2019s search function was gated through centralized data validation routines, the ability to perform SQL injection is dramatically reduced. However, if the help feature was re-written to eliminate the search function (through a better user interface, for example), this almost eliminates the attack surface area, even if the help feature was available to the Internet at large. Establish secure defaults: There are many ways to deliver an \u201cout of the box\u201d experience for users. However, by default, the experience should be secure, and it should be up to the user to reduce their security \u2013 if they are allowed. For example, by default, password ageing and complexity should be enabled. Users might be allowed to turn these two features off to simplify their use of the application and increase their risk. Default Passwords of routers, IoT devices should be changed Principle of Least privilege The principle of least privilege recommends that accounts have the least amount of privilege required to perform their business processes. This encompasses user rights, resource permissions such as CPU limits, memory, network, and file system permissions. For example, if a middleware server only requires access to the network, read access to a database table, and the ability to write to a log, this describes all the permissions that should be granted. Under no circumstances should the middleware be granted administrative privileges. Principle of Defense in depth The principle of defence in depth suggests that where one control would be reasonable, more controls that approach risks in different fashions are better. Controls, when used in depth, can make severe vulnerabilities extraordinarily difficult to exploit and thus unlikely to occur. With secure coding, this may take the form of tier-based validation, centralized auditing controls, and requiring users to be logged on all pages. For example, a flawed administrative interface is unlikely to be vulnerable to an anonymous attack if it correctly gates access to production management networks, checks for administrative user authorization, and logs all access. Fail securely Applications regularly fail to process transactions for many reasons. How they fail can determine if an application is secure or not. ``` is_admin = true; try { code_which_may_faile(); is_admin = is_user_assigned_role(\"Adminstrator\"); } catch (Exception err) { log.error(err.toString()); } ``` - If either codeWhichMayFail() or isUserInRole fails or throws an exception, the user is an admin by default. This is obviously a security risk. Don\u2019t trust services Many organizations utilize the processing capabilities of third-party partners, who more than likely have different security policies and posture than you. It is unlikely that you can influence or control any external third party, whether they are home users or major suppliers or partners. Therefore, the implicit trust of externally run systems is not warranted. All external systems should be treated similarly. For example, a loyalty program provider provides data that is used by Internet Banking, providing the number of reward points and a small list of potential redemption items. However, the data should be checked to ensure that it is safe to display to end-users and that the reward points are a positive number, and not improbably large. Separation of duties The key to fraud control is the separation of duties. For example, someone who requests a computer cannot also sign for it, nor should they directly receive the computer. This prevents the user from requesting many computers and claiming they never arrived. Certain roles have different levels of trust than normal users. In particular, administrators are different from normal users. In general, administrators should not be users of the application. For example, an administrator should be able to turn the system on or off, set password policy but shouldn\u2019t be able to log on to the storefront as a super privileged user, such as being able to \u201cbuy\u201d goods on behalf of other users. Avoid security by obscurity Security through obscurity is a weak security control, and nearly always fails when it is the only control. This is not to say that keeping secrets is a bad idea, it simply means that the security of systems should not be reliant upon keeping details hidden. For example, the security of an application should not rely upon knowledge of the source code being kept secret. The security should rely upon many other factors, including reasonable password policies, defence in depth, business transaction limits, solid network architecture, and fraud, and audit controls. A practical example is Linux. Linux\u2019s source code is widely available, and yet when properly secured, Linux is a secure and robust operating system. Keep security simple Attack surface area and simplicity go hand in hand. Certain software engineering practices prefer overly complex approaches to what would otherwise be a relatively straightforward and simple design. Developers should avoid the use of double negatives and complex architectures when a simpler approach would be faster and simpler. For example, although it might be fashionable to have a slew of singleton entity beans running on a separate middleware server, it is more secure and faster to simply use global variables with an appropriate mutex mechanism to protect against race conditions. Fix security issues correctly Once a security issue has been identified, it is important to develop a test for it and to understand the root cause of the issue. When design patterns are used, the security issue is likely widespread amongst all codebases, so developing the right fix without introducing regressions is essential. For example, a user has found that they can see another user\u2019s balance by adjusting their cookie. The fix seems to be relatively straightforward, but as the cookie handling code is shared among all applications, a change to just one application will trickle through to all other applications. The fix must, therefore, be tested on all affected applications. Reliability & Security Reliability and security are both crucial components of a truly trustworthy system, but building systems that are both reliable and secure is difficult. While the requirements for reliability and security share many common properties, they also require different design considerations. It is easy to miss the subtle interplay between reliability and security that can cause unexpected outcomes Ex: A password management application failure was triggered by a reliability problem i.e poor load-balancing and load-shedding strategies and its recovery were later complicated by multiple measures (HSM mechanism which needs to be plugged into server racks, which works as an authentication & the HSM token supposedly locked inside a case.. & the problem can be further elongated ) designed to increase the security of the system. Authentication vs Authorization Authentication is the act of validating that users are who they claim to be. Passwords are the most common authentication factor\u2014if a user enters the correct password, the system assumes the identity is valid and grants access. Other technologies such as One-Time Pins, authentication apps, and even biometrics can also be used to authenticate identity. In some instances, systems require the successful verification of more than one factor before granting access. This multi-factor authentication (MFA) requirement is often deployed to increase security beyond what passwords alone can provide. Authorization in system security is the process of giving the user permission to access a specific resource or function. This term is often used interchangeably with access control or client privilege. Giving someone permission to download a particular file on a server or providing individual users with administrative access to an application are good examples. In secure environments, authorization must always follow authentication, users should first prove that their identities are genuine before an organization\u2019s administrators grant them access to the requested resources. Common authentication flow (local authentication) The user registers using an identifier like username/email/mobile The application stores user credentials in the database The application sends a verification email/message to validate the registration Post successful registration, the user enters credentials for logging in On successful authentication, the user is allowed access to specific resources OpenID/OAuth OpenID is an authentication protocol that allows us to authenticate users without using a local auth system. In such a scenario, a user has to be registered with an OpenID Provider and the same provider should be integrated with the authentication flow of your application. To verify the details, we have to forward the authentication requests to the provider. On successful authentication, we receive a success message and/or profile details with which we can execute the necessary flow. OAuth is an authorization mechanism that allows your application user access to a provider(Gmail/Facebook/Instagram/etc). On successful response, we (your application) receive a token with which the application can access certain APIs on behalf of a user. OAuth is convenient in case your business use case requires some certain user-facing APIs like access to Google Drive or sending tweets on your behalf. Most OAuth 2.0 providers can be used for pseudo authentication. Having said that, it can get pretty complicated if you are using multiple OAuth providers to authenticate users on top of the local authentication system. Cryptography It is the science and study of hiding any text in such a way that only the intended recipients or authorized persons can read it and that any text can even use things such as invisible ink or the mechanical cryptography machines of the past. Cryptography is necessary for securing critical or proprietary information and is used to encode private data messages by converting some plain text into ciphertext. At its core, there are two ways of doing this, more advanced methods are all built upon. Ciphers Ciphers are the cornerstone of cryptography. A cipher is a set of algorithms that performs encryption or decryption on a message. An encryption algorithm (E) takes a secret key (k) and a message (m) and produces a ciphertext (c). Similarly, a Decryption algorithm (D) takes a secret key (K) and the previous resulting Ciphertext (C). They are represented as follows: E(k,m) = c D(k,c) = m This also means that for it to be a cipher, it must satisfy the consistency equation as follows, making it possible to decrypt. D(k,E(k,m)) = m Stream Ciphers: The message is broken into characters or bits and enciphered with a key or keystream(should be random and generated independently of the message stream) that is as long as the plaintext bitstream. If the keystream is random, this scheme would be unbreakable unless the keystream was acquired, making it unconditionally secure. The keystream must be provided to both parties in a secure way to prevent its release. Block Ciphers: Block ciphers \u2014 process messages in blocks, each of which is then encrypted or decrypted. A block cipher is a symmetric cipher in which blocks of plaintext are treated as a whole and used to produce ciphertext blocks. The block cipher takes blocks that are b bits long and encrypts them to blocks that are also b bits long. Block sizes are typically 64 or 128 bits long. Encryption Secret Key (Symmetric Key) : the same key is used for encryption and decryption Public Key (Asymmetric Key) in an asymmetric, the encryption and decryption keys are different but related. The encryption key is known as the public key and the decryption key is known as the private key. The public and private keys are known as a key pair. Symmetric Key Encryption DES The Data Encryption Standard (DES) has been the worldwide encryption standard for a long time. IBM developed DES in 1975, and it has held up remarkably well against years of cryptanalysis. DES is a symmetric encryption algorithm with a fixed key length of 56 bits. The algorithm is still good, but because of the short key length, it is susceptible to brute-force attacks that have sufficient resources. DES usually operates in block mode, whereby it encrypts data in 64-bit blocks. The same algorithm and key are used for both encryption and decryption. Because DES is based on simple mathematical functions, it can be easily implemented and accelerated in hardware. Triple DES With advances in computer processing power, the original 56-bit DES key became too short to withstand an attacker with even a limited budget. One way of increasing the effective key length of DES without changing the well-analyzed algorithm itself is to use the same algorithm with different keys several times in a row. The technique of applying DES three times in a row to a plain text block is called Triple DES (3DES). The 3DES technique is shown in Figure. Brute-force attacks on 3DES are considered unfeasible today. Because the basic algorithm has been tested in the field for more than 25 years, it is considered to be more trustworthy than its predecessor. AES On October 2, 2000, The U.S. National Institute of Standards and Technology (NIST) announced the selection of the Rijndael cipher as the AES algorithm. This cipher, developed by Joan Daemen and Vincent Rijmen, has a variable block length and key length. The algorithm currently specifies how to use keys with a length of 128, 192, or 256 bits to encrypt blocks with a length of 128, 192, or 256 bits (all nine combinations of key length and block length are possible). Both block and key lengths can be extended easily to multiples of 32 bits. AES was chosen to replace DES and 3DES because they are either too weak (DES, in terms of key length) or too slow (3DES) to run on modern, efficient hardware. AES is more efficient and much faster, usually by a factor of 5 compared to DES on the same hardware. AES is also more suitable for high throughput, especially if pure software encryption is used. However, AES is a relatively young algorithm, and as the golden rule of cryptography states, \u201cA more mature algorithm is always more trusted.\u201d Asymmetric Key Algorithm In a symmetric key system, Alice first puts the secret message in a box and then padlocks the box using a lock to which she has a key. She then sends the box to Bob through regular mail. When Bob receives the box, he uses an identical copy of Alice's key (which he has obtained previously) to open the box and read the message. In an asymmetric key system, instead of opening the box when he receives it, Bob simply adds his own personal lock to the box and returns the box through public mail to Alice. Alice uses her key to remove her lock and returns the box to Bob, with Bob's lock still in place. Finally, Bob uses his key to remove his lock and reads the message from Alice. The critical advantage in an asymmetric system is that Alice never needs to send a copy of her key to Bob. This reduces the possibility that a third party (for example, an unscrupulous postmaster) can copy the key while it is in transit to Bob, allowing that third party to spy on all future messages sent by Alice. In addition, if Bob is careless and allows someone else to copy his key, Alice's messages to Bob are compromised, but Alice's messages to other people remain secret NOTE : In terms of TLS key exchange, this is the common approach. Diffie-Hellman The protocol has two system parameters, p and g. They are both public and may be used by everybody. Parameter p is a prime number, and parameter g (usually called a generator) is an integer that is smaller than p, but with the following property: For every number n between 1 and p \u2013 1 inclusive, there is a power k of g such that n = gk mod p. Diffie Hellman algorithm is an asymmetric algorithm used to establish a shared secret for a symmetric key algorithm. Nowadays most of the people use hybrid cryptosystem i.e, a combination of symmetric and asymmetric encryption. Asymmetric Encryption is used as a technique in key exchange mechanism to share a secret key and after the key is shared between sender and receiver, the communication will take place using symmetric encryption. The shared secret key will be used to encrypt the communication. Refer: https://medium.com/@akhigbemmanuel/what-is-the-diffie-hellman-key-exchange-algorithm-84d60025a30d RSA The RSA algorithm is very flexible and has a variable key length where, if necessary, speed can be traded for the level of security of the algorithm. The RSA keys are usually 512 to 2048 bits long. RSA has withstood years of extensive cryptanalysis. Although those years neither proved nor disproved RSA's security, they attest to a confidence level in the algorithm. RSA security is based on the difficulty of factoring very large numbers. If an easy method of factoring these large numbers were discovered, the effectiveness of RSA would be destroyed. Refer: https://medium.com/curiositypapers/a-complete-explanation-of-rsa-asymmetric-encryption-742c5971e0f NOTE : RSA Keys can be used for key exchange just like Diffie Hellman Hashing Algorithms Hashing is one of the mechanisms used for data integrity assurance. Hashing is based on a one-way mathematical function, which is relatively easy to compute but significantly harder to reverse. A hash function, which is a one-way function to input data to produce a fixed-length digest (fingerprint) of output data. The digest is cryptographically strong; that is, it is impossible to recover input data from its digest. If the input data changes just a little, the digest (fingerprint) changes substantially in what is called an avalanche effect. More: https://medium.com/@rauljordan/the-state-of-hashing-algorithms-the-why-the-how-and-the-future-b21d5c0440de https://medium.com/@StevieCEllis/the-beautiful-hash-algorithm-f18d9d2b84fb MD5 MD5 is a one-way function with which it is easy to compute the hash from the given input data, but it is unfeasible to compute input data given only a hash. SHA-1 MD5 is considered less secure than SHA-1 because MD5 has some weaknesses. HA-1 also uses a stronger, 160-bit digest, which makes MD5 the second choice as hash methods are concerned. The algorithm takes a message of less than 264 bits in length and produces a 160-bit message digest. This algorithm is slightly slower than MD5. NOTE : SHA-1 is also recently demonstrated to be broken, Minimum current recommendation is SHA-256 Digital Certificates Digital signatures, provide a means to digitally authenticate devices and individual users. In public-key cryptography, such as the RSA encryption system, each user has a key-pair containing both a public key and a private key. The keys act as complements, and anything encrypted with one of the keys can be decrypted with the other. In simple terms, a signature is formed when data is encrypted with a user's private key. The receiver verifies the signature by decrypting the message with the sender's public key. Key management is often considered the most difficult task in designing and implementing cryptographic systems. Businesses can simplify some of the deployment and management issues that are encountered with secured data communications by employing a Public Key Infrastructure (PKI). Because corporations often move security-sensitive communications across the Internet, an effective mechanism must be implemented to protect sensitive information from the threats presented on the Internet. PKI provides a hierarchical framework for managing digital security attributes. Each PKI participant holds a digital certificate that has been issued by a CA (either public or private). The certificate contains several attributes that are used when parties negotiate a secure connection. These attributes must include the certificate validity period, end-host identity information, encryption keys that will be used for secure communications, and the signature of the issuing CA. Optional attributes may be included, depending on the requirements and capability of the PKI. A CA can be a trusted third party, such as VeriSign or Entrust, or a private (in-house) CA that you establish within your organization. The fact that the message could be decrypted using the sender's public key means that the holder of the private key created the message. This process relies on the receiver having a copy of the sender's public key and knowing with a high degree of certainty that it really does belong to the sender and not to someone pretending to be the sender. To validate the CA's signature, the receiver must know the CA's public key. Normally, this is handled out-of-band or through an operation performed during the installation of the certificate. For instance, most web browsers are configured with the root certificates of several CAs by default. CA Enrollment process The end host generates a private-public key pair. The end host generates a certificate request, which it forwards to the CA. Manual human intervention is required to approve the enrollment request, which is received by the CA. After the CA operator approves the request, the CA signs the certificate request with its private key and returns the completed certificate to the end host. The end host writes the certificate into a nonvolatile storage area (PC hard disk or NVRAM on Cisco routers). Refer : https://www.ssh.com/manuals/server-zos-product/55/ch06s03s01.html Login Security SSH SSH, the Secure Shell, is a popular, powerful, software-based approach to network security. Whenever data is sent by a computer to the network, SSH automatically encrypts (scrambles) it. Then, when the data reaches its intended recipient, SSH automatically decrypts (unscrambles) it. The result is transparent encryption: users can work normally, unaware that their communications are safely encrypted on the network. In addition, SSH can use modern, secure encryption algorithms based on how it's being configured and is effective enough to be found within mission-critical applications at major corporations. SSH has a client/server architecture An SSH server program, typically installed and run by a system administrator, accepts or rejects incoming connections to its host computer. Users then run SSH client programs, typically on other computers, to make requests of the SSH server, such as \u201cPlease log me in,\u201d \u201cPlease send me a file,\u201d or \u201cPlease execute this command.\u201d All communications between clients and servers are securely encrypted and protected from modification. What SSH is not: Although SSH stands for Secure Shell, it is not a true shell in the sense of the Unix Bourne shell and C shell. It is not a command interpreter, nor does it provide wildcard expansion, command history, and so forth. Rather, SSH creates a channel for running a shell on a remote computer, with end-to-end encryption between the two systems. The major features and guarantees of the SSH protocol are: Privacy of your data, via strong encryption Integrity of communications, guaranteeing they haven\u2019t been altered Authentication, i.e., proof of identity of senders and receivers Authorization, i.e., access control to accounts Forwarding or tunnelling to encrypt other TCP/IP-based sessions Kerberos According to Greek mythology Kerberos (Cerberus) was the gigantic, three-headed dog that guards the gates of the underworld to prevent the dead from leaving. So when it comes to Computer Science, Kerberos is a network authentication protocol and is currently the default authentication technology used by Microsoft Active Directory to authenticate users to services within a local area network. Kerberos uses symmetric-key cryptography and requires a trusted third-party authentication service to verify user identities. So they used the name of Kerberos for their computer network authentication protocol as the three heads of the Kerberos represent: a client: A user/ a service a server: Kerberos protected hosts reside - a Key Distribution Center (KDC), which acts as the trusted third-party authentication service. The KDC includes the following two servers: Authentication Server (AS) that performs the initial authentication and issues ticket-granting tickets (TGT) for users. Ticket-Granting Server (TGS) that issues service tickets that are based on the initial ticket-granting tickets (TGT). Certificate Chain The first part of the output of the OpenSSL command shows three certificates numbered 0, 1, and 2(not 2 anymore). Each certificate has a subject, s, and an issuer, i. The first certificate, number 0, is called the end-entity certificate. The subject line tells us it\u2019s valid for any subdomain of google.com because its subject is set to *.google.com. $ openssl s_client -connect www.google.com:443 -CApath /etc/ssl/certs CONNECTED(00000005) depth=2 OU = GlobalSign Root CA - R2, O = GlobalSign, CN = GlobalSign verify return:1 depth=1 C = US, O = Google Trust Services, CN = GTS CA 1O1 verify return:1 depth=0 C = US, ST = California, L = Mountain View, O = Google LLC, CN = www.google.com verify return:1 --- Certificate chain 0 s:/C=US/ST=California/L=Mountain View/O=Google LLC/CN=www.google.com i:/C=US/O=Google Trust Services/CN=GTS CA 1O1 1 s:/C=US/O=Google Trust Services/CN=GTS CA 1O1 i:/OU=GlobalSign Root CA - R2/O=GlobalSign/CN=GlobalSign --- Server certificate The issuer line indicates it\u2019s issued by Google Internet Authority G2, which also happens to be the subject of the second certificate, number 1 What the OpenSSL command line doesn\u2019t show here is the trust store that contains the list of CA certificates trusted by the system OpenSSL runs on. The public certificate of GlobalSign Authority must be present in the system\u2019s trust store to close the verification chain. This is called a chain of trust, and the figure below summarizes its behaviour at a high level. High-level view of the concept of chain of trust applied to verifying the authenticity of a website. The Root CA in the Firefox trust store provides the initial trust to verify the entire chain and trust the end-entity certificate. TLS Handshake The client sends a HELLO message to the server with a list of protocols and algorithms it supports. The server says HELLO back and sends its chain of certificates. Based on the capabilities of the client, the server picks a cipher suite. If the cipher suite supports ephemeral key exchange, like ECDHE does(ECDHE is an algorithm known as the Elliptic Curve Diffie-Hellman Exchange), the server and the client negotiate a pre-master key with the Diffie-Hellman algorithm. The pre-master key is never sent over the wire. The client and server create a session key that will be used to encrypt the data transiting through the connection. At the end of the handshake, both parties possess a secret session key used to encrypt data for the rest of the connection. This is what OpenSSL refers to as Master-Key NOTE There are 3 versions of TLS , TLS 1.0, 1.1 & 1.2 TLS 1.0 was released in 1999, making it a nearly two-decade-old protocol. It has been known to be vulnerable to attacks\u2014such as BEAST and POODLE\u2014for years, in addition to supporting weak cryptography, which doesn\u2019t keep modern-day connections sufficiently secure. TLS 1.1 is the forgotten \u201cmiddle child.\u201d It also has bad cryptography like its younger sibling. In most software, it was leapfrogged by TLS 1.2 and it\u2019s rare to see TLS 1.1 used. \u201cPerfect\u201d Forward Secrecy The term \u201cephemeral\u201d in the key exchange provides an important security feature mis-named perfect forward secrecy (PFS) or just \u201cForward Secrecy\u201d. In a non-ephemeral key exchange, the client sends the pre-master key to the server by encrypting it with the server\u2019s public key. The server then decrypts the pre-master key with its private key. If at a later point in time, the private key of the server is compromised, an attacker can go back to this handshake, decrypt the pre-master key, obtain the session key, and decrypt the entire traffic. Non-ephemeral key exchanges are vulnerable to attacks that may happen in the future on recorded traffic. And because people seldom change their password, decrypting data from the past may still be valuable for an attacker. An ephemeral key exchange like DHE, or its variant on elliptic curve, ECDHE, solves this problem by not transmitting the pre-master key over the wire. Instead, the pre-master key is computed by both the client and the server in isolation, using nonsensitive information exchanged publicly. Because the pre-master key can\u2019t be decrypted later by an attacker, the session key is safe from future attacks: hence, the term perfect forward secrecy. Keys are changed every X blocks along the stream. That prevents an attacker from simply sniffing the stream and applying brute force to crack the whole thing. \"Forward secrecy\" means that just because I can decrypt block M, does not mean that I can decrypt block Q Downside: The downside to PFS is that all those extra computational steps induce latency on the handshake and slow the user down. To avoid repeating this expensive work at every connection, both sides cache the session key for future use via a technique called session resumption. This is what the session-ID and TLS ticket are for: they allow a client and server that share a session ID to skip over the negotiation of a session key, because they already agreed on one previously, and go directly to exchanging data securely.","title":"Fundamentals of Security"},{"location":"level101/security/fundamentals/#part-i-fundamentals","text":"","title":"Part I: Fundamentals"},{"location":"level101/security/fundamentals/#introduction-to-security-overview-for-sre","text":"If you look closely, both Site Reliability Engineering and Security Engineering are concerned with keeping a system usable. Issues like broken releases, capacity shortages, and misconfigurations can make a system unusable (at least temporarily). Security or privacy incidents that break the trust of users also undermine the usefulness of a system. Consequently, system security should be top of mind for SREs. SREs should be involved in both significant design discussions and actual system changes. They have quite a big role in System design & hence are quite sometimes the first line of defence. SRE\u2019s help in preventing bad design & implementations which can affect the overall security of the infrastructure. Successfully designing, implementing, and maintaining systems requires a commitment to the full system lifecycle . This commitment is possible only when security and reliability are central elements in the architecture of systems. Core Pillars of Information Security : Confidentiality \u2013 only allow access to data for which the user is permitted Integrity \u2013 ensure data is not tampered or altered by unauthorized users Availability \u2013 ensure systems and data are available to authorized users when they need it Thinking like a Security Engineer When starting a new application or re-factoring an existing application, you should consider each functional feature, and consider: Is the process surrounding this feature as safe as possible? In other words, is this a flawed process? If I were evil, how would I abuse this feature? Or more specifically failing to address how a feature can be abused can cause design flaws. Is the feature required to be on by default? If so, are there limits or options that could help reduce the risk from this feature? Security Principles By OWASP (Open Web Application Security Project) Minimize attack surface area : Every feature that is added to an application adds a certain amount of risk to the overall application. The aim of secure development is to reduce the overall risk by reducing the attack surface area. For example, a web application implements online help with a search function. The search function may be vulnerable to SQL injection attacks. If the help feature was limited to authorized users, the attack likelihood is reduced. If the help feature\u2019s search function was gated through centralized data validation routines, the ability to perform SQL injection is dramatically reduced. However, if the help feature was re-written to eliminate the search function (through a better user interface, for example), this almost eliminates the attack surface area, even if the help feature was available to the Internet at large. Establish secure defaults: There are many ways to deliver an \u201cout of the box\u201d experience for users. However, by default, the experience should be secure, and it should be up to the user to reduce their security \u2013 if they are allowed. For example, by default, password ageing and complexity should be enabled. Users might be allowed to turn these two features off to simplify their use of the application and increase their risk. Default Passwords of routers, IoT devices should be changed Principle of Least privilege The principle of least privilege recommends that accounts have the least amount of privilege required to perform their business processes. This encompasses user rights, resource permissions such as CPU limits, memory, network, and file system permissions. For example, if a middleware server only requires access to the network, read access to a database table, and the ability to write to a log, this describes all the permissions that should be granted. Under no circumstances should the middleware be granted administrative privileges. Principle of Defense in depth The principle of defence in depth suggests that where one control would be reasonable, more controls that approach risks in different fashions are better. Controls, when used in depth, can make severe vulnerabilities extraordinarily difficult to exploit and thus unlikely to occur. With secure coding, this may take the form of tier-based validation, centralized auditing controls, and requiring users to be logged on all pages. For example, a flawed administrative interface is unlikely to be vulnerable to an anonymous attack if it correctly gates access to production management networks, checks for administrative user authorization, and logs all access. Fail securely Applications regularly fail to process transactions for many reasons. How they fail can determine if an application is secure or not. ``` is_admin = true; try { code_which_may_faile(); is_admin = is_user_assigned_role(\"Adminstrator\"); } catch (Exception err) { log.error(err.toString()); } ``` - If either codeWhichMayFail() or isUserInRole fails or throws an exception, the user is an admin by default. This is obviously a security risk. Don\u2019t trust services Many organizations utilize the processing capabilities of third-party partners, who more than likely have different security policies and posture than you. It is unlikely that you can influence or control any external third party, whether they are home users or major suppliers or partners. Therefore, the implicit trust of externally run systems is not warranted. All external systems should be treated similarly. For example, a loyalty program provider provides data that is used by Internet Banking, providing the number of reward points and a small list of potential redemption items. However, the data should be checked to ensure that it is safe to display to end-users and that the reward points are a positive number, and not improbably large. Separation of duties The key to fraud control is the separation of duties. For example, someone who requests a computer cannot also sign for it, nor should they directly receive the computer. This prevents the user from requesting many computers and claiming they never arrived. Certain roles have different levels of trust than normal users. In particular, administrators are different from normal users. In general, administrators should not be users of the application. For example, an administrator should be able to turn the system on or off, set password policy but shouldn\u2019t be able to log on to the storefront as a super privileged user, such as being able to \u201cbuy\u201d goods on behalf of other users. Avoid security by obscurity Security through obscurity is a weak security control, and nearly always fails when it is the only control. This is not to say that keeping secrets is a bad idea, it simply means that the security of systems should not be reliant upon keeping details hidden. For example, the security of an application should not rely upon knowledge of the source code being kept secret. The security should rely upon many other factors, including reasonable password policies, defence in depth, business transaction limits, solid network architecture, and fraud, and audit controls. A practical example is Linux. Linux\u2019s source code is widely available, and yet when properly secured, Linux is a secure and robust operating system. Keep security simple Attack surface area and simplicity go hand in hand. Certain software engineering practices prefer overly complex approaches to what would otherwise be a relatively straightforward and simple design. Developers should avoid the use of double negatives and complex architectures when a simpler approach would be faster and simpler. For example, although it might be fashionable to have a slew of singleton entity beans running on a separate middleware server, it is more secure and faster to simply use global variables with an appropriate mutex mechanism to protect against race conditions. Fix security issues correctly Once a security issue has been identified, it is important to develop a test for it and to understand the root cause of the issue. When design patterns are used, the security issue is likely widespread amongst all codebases, so developing the right fix without introducing regressions is essential. For example, a user has found that they can see another user\u2019s balance by adjusting their cookie. The fix seems to be relatively straightforward, but as the cookie handling code is shared among all applications, a change to just one application will trickle through to all other applications. The fix must, therefore, be tested on all affected applications. Reliability & Security Reliability and security are both crucial components of a truly trustworthy system, but building systems that are both reliable and secure is difficult. While the requirements for reliability and security share many common properties, they also require different design considerations. It is easy to miss the subtle interplay between reliability and security that can cause unexpected outcomes Ex: A password management application failure was triggered by a reliability problem i.e poor load-balancing and load-shedding strategies and its recovery were later complicated by multiple measures (HSM mechanism which needs to be plugged into server racks, which works as an authentication & the HSM token supposedly locked inside a case.. & the problem can be further elongated ) designed to increase the security of the system.","title":"Introduction to Security Overview for SRE"},{"location":"level101/security/fundamentals/#authentication-vs-authorization","text":"Authentication is the act of validating that users are who they claim to be. Passwords are the most common authentication factor\u2014if a user enters the correct password, the system assumes the identity is valid and grants access. Other technologies such as One-Time Pins, authentication apps, and even biometrics can also be used to authenticate identity. In some instances, systems require the successful verification of more than one factor before granting access. This multi-factor authentication (MFA) requirement is often deployed to increase security beyond what passwords alone can provide. Authorization in system security is the process of giving the user permission to access a specific resource or function. This term is often used interchangeably with access control or client privilege. Giving someone permission to download a particular file on a server or providing individual users with administrative access to an application are good examples. In secure environments, authorization must always follow authentication, users should first prove that their identities are genuine before an organization\u2019s administrators grant them access to the requested resources.","title":"Authentication vs Authorization"},{"location":"level101/security/fundamentals/#common-authentication-flow-local-authentication","text":"The user registers using an identifier like username/email/mobile The application stores user credentials in the database The application sends a verification email/message to validate the registration Post successful registration, the user enters credentials for logging in On successful authentication, the user is allowed access to specific resources","title":"Common authentication flow (local authentication)"},{"location":"level101/security/fundamentals/#openidoauth","text":"OpenID is an authentication protocol that allows us to authenticate users without using a local auth system. In such a scenario, a user has to be registered with an OpenID Provider and the same provider should be integrated with the authentication flow of your application. To verify the details, we have to forward the authentication requests to the provider. On successful authentication, we receive a success message and/or profile details with which we can execute the necessary flow. OAuth is an authorization mechanism that allows your application user access to a provider(Gmail/Facebook/Instagram/etc). On successful response, we (your application) receive a token with which the application can access certain APIs on behalf of a user. OAuth is convenient in case your business use case requires some certain user-facing APIs like access to Google Drive or sending tweets on your behalf. Most OAuth 2.0 providers can be used for pseudo authentication. Having said that, it can get pretty complicated if you are using multiple OAuth providers to authenticate users on top of the local authentication system.","title":"OpenID/OAuth"},{"location":"level101/security/fundamentals/#cryptography","text":"It is the science and study of hiding any text in such a way that only the intended recipients or authorized persons can read it and that any text can even use things such as invisible ink or the mechanical cryptography machines of the past. Cryptography is necessary for securing critical or proprietary information and is used to encode private data messages by converting some plain text into ciphertext. At its core, there are two ways of doing this, more advanced methods are all built upon.","title":"Cryptography"},{"location":"level101/security/fundamentals/#ciphers","text":"Ciphers are the cornerstone of cryptography. A cipher is a set of algorithms that performs encryption or decryption on a message. An encryption algorithm (E) takes a secret key (k) and a message (m) and produces a ciphertext (c). Similarly, a Decryption algorithm (D) takes a secret key (K) and the previous resulting Ciphertext (C). They are represented as follows: E(k,m) = c D(k,c) = m This also means that for it to be a cipher, it must satisfy the consistency equation as follows, making it possible to decrypt. D(k,E(k,m)) = m Stream Ciphers: The message is broken into characters or bits and enciphered with a key or keystream(should be random and generated independently of the message stream) that is as long as the plaintext bitstream. If the keystream is random, this scheme would be unbreakable unless the keystream was acquired, making it unconditionally secure. The keystream must be provided to both parties in a secure way to prevent its release. Block Ciphers: Block ciphers \u2014 process messages in blocks, each of which is then encrypted or decrypted. A block cipher is a symmetric cipher in which blocks of plaintext are treated as a whole and used to produce ciphertext blocks. The block cipher takes blocks that are b bits long and encrypts them to blocks that are also b bits long. Block sizes are typically 64 or 128 bits long. Encryption Secret Key (Symmetric Key) : the same key is used for encryption and decryption Public Key (Asymmetric Key) in an asymmetric, the encryption and decryption keys are different but related. The encryption key is known as the public key and the decryption key is known as the private key. The public and private keys are known as a key pair. Symmetric Key Encryption DES The Data Encryption Standard (DES) has been the worldwide encryption standard for a long time. IBM developed DES in 1975, and it has held up remarkably well against years of cryptanalysis. DES is a symmetric encryption algorithm with a fixed key length of 56 bits. The algorithm is still good, but because of the short key length, it is susceptible to brute-force attacks that have sufficient resources. DES usually operates in block mode, whereby it encrypts data in 64-bit blocks. The same algorithm and key are used for both encryption and decryption. Because DES is based on simple mathematical functions, it can be easily implemented and accelerated in hardware. Triple DES With advances in computer processing power, the original 56-bit DES key became too short to withstand an attacker with even a limited budget. One way of increasing the effective key length of DES without changing the well-analyzed algorithm itself is to use the same algorithm with different keys several times in a row. The technique of applying DES three times in a row to a plain text block is called Triple DES (3DES). The 3DES technique is shown in Figure. Brute-force attacks on 3DES are considered unfeasible today. Because the basic algorithm has been tested in the field for more than 25 years, it is considered to be more trustworthy than its predecessor. AES On October 2, 2000, The U.S. National Institute of Standards and Technology (NIST) announced the selection of the Rijndael cipher as the AES algorithm. This cipher, developed by Joan Daemen and Vincent Rijmen, has a variable block length and key length. The algorithm currently specifies how to use keys with a length of 128, 192, or 256 bits to encrypt blocks with a length of 128, 192, or 256 bits (all nine combinations of key length and block length are possible). Both block and key lengths can be extended easily to multiples of 32 bits. AES was chosen to replace DES and 3DES because they are either too weak (DES, in terms of key length) or too slow (3DES) to run on modern, efficient hardware. AES is more efficient and much faster, usually by a factor of 5 compared to DES on the same hardware. AES is also more suitable for high throughput, especially if pure software encryption is used. However, AES is a relatively young algorithm, and as the golden rule of cryptography states, \u201cA more mature algorithm is always more trusted.\u201d Asymmetric Key Algorithm In a symmetric key system, Alice first puts the secret message in a box and then padlocks the box using a lock to which she has a key. She then sends the box to Bob through regular mail. When Bob receives the box, he uses an identical copy of Alice's key (which he has obtained previously) to open the box and read the message. In an asymmetric key system, instead of opening the box when he receives it, Bob simply adds his own personal lock to the box and returns the box through public mail to Alice. Alice uses her key to remove her lock and returns the box to Bob, with Bob's lock still in place. Finally, Bob uses his key to remove his lock and reads the message from Alice. The critical advantage in an asymmetric system is that Alice never needs to send a copy of her key to Bob. This reduces the possibility that a third party (for example, an unscrupulous postmaster) can copy the key while it is in transit to Bob, allowing that third party to spy on all future messages sent by Alice. In addition, if Bob is careless and allows someone else to copy his key, Alice's messages to Bob are compromised, but Alice's messages to other people remain secret NOTE : In terms of TLS key exchange, this is the common approach. Diffie-Hellman The protocol has two system parameters, p and g. They are both public and may be used by everybody. Parameter p is a prime number, and parameter g (usually called a generator) is an integer that is smaller than p, but with the following property: For every number n between 1 and p \u2013 1 inclusive, there is a power k of g such that n = gk mod p. Diffie Hellman algorithm is an asymmetric algorithm used to establish a shared secret for a symmetric key algorithm. Nowadays most of the people use hybrid cryptosystem i.e, a combination of symmetric and asymmetric encryption. Asymmetric Encryption is used as a technique in key exchange mechanism to share a secret key and after the key is shared between sender and receiver, the communication will take place using symmetric encryption. The shared secret key will be used to encrypt the communication. Refer: https://medium.com/@akhigbemmanuel/what-is-the-diffie-hellman-key-exchange-algorithm-84d60025a30d RSA The RSA algorithm is very flexible and has a variable key length where, if necessary, speed can be traded for the level of security of the algorithm. The RSA keys are usually 512 to 2048 bits long. RSA has withstood years of extensive cryptanalysis. Although those years neither proved nor disproved RSA's security, they attest to a confidence level in the algorithm. RSA security is based on the difficulty of factoring very large numbers. If an easy method of factoring these large numbers were discovered, the effectiveness of RSA would be destroyed. Refer: https://medium.com/curiositypapers/a-complete-explanation-of-rsa-asymmetric-encryption-742c5971e0f NOTE : RSA Keys can be used for key exchange just like Diffie Hellman Hashing Algorithms Hashing is one of the mechanisms used for data integrity assurance. Hashing is based on a one-way mathematical function, which is relatively easy to compute but significantly harder to reverse. A hash function, which is a one-way function to input data to produce a fixed-length digest (fingerprint) of output data. The digest is cryptographically strong; that is, it is impossible to recover input data from its digest. If the input data changes just a little, the digest (fingerprint) changes substantially in what is called an avalanche effect. More: https://medium.com/@rauljordan/the-state-of-hashing-algorithms-the-why-the-how-and-the-future-b21d5c0440de https://medium.com/@StevieCEllis/the-beautiful-hash-algorithm-f18d9d2b84fb MD5 MD5 is a one-way function with which it is easy to compute the hash from the given input data, but it is unfeasible to compute input data given only a hash. SHA-1 MD5 is considered less secure than SHA-1 because MD5 has some weaknesses. HA-1 also uses a stronger, 160-bit digest, which makes MD5 the second choice as hash methods are concerned. The algorithm takes a message of less than 264 bits in length and produces a 160-bit message digest. This algorithm is slightly slower than MD5. NOTE : SHA-1 is also recently demonstrated to be broken, Minimum current recommendation is SHA-256 Digital Certificates Digital signatures, provide a means to digitally authenticate devices and individual users. In public-key cryptography, such as the RSA encryption system, each user has a key-pair containing both a public key and a private key. The keys act as complements, and anything encrypted with one of the keys can be decrypted with the other. In simple terms, a signature is formed when data is encrypted with a user's private key. The receiver verifies the signature by decrypting the message with the sender's public key. Key management is often considered the most difficult task in designing and implementing cryptographic systems. Businesses can simplify some of the deployment and management issues that are encountered with secured data communications by employing a Public Key Infrastructure (PKI). Because corporations often move security-sensitive communications across the Internet, an effective mechanism must be implemented to protect sensitive information from the threats presented on the Internet. PKI provides a hierarchical framework for managing digital security attributes. Each PKI participant holds a digital certificate that has been issued by a CA (either public or private). The certificate contains several attributes that are used when parties negotiate a secure connection. These attributes must include the certificate validity period, end-host identity information, encryption keys that will be used for secure communications, and the signature of the issuing CA. Optional attributes may be included, depending on the requirements and capability of the PKI. A CA can be a trusted third party, such as VeriSign or Entrust, or a private (in-house) CA that you establish within your organization. The fact that the message could be decrypted using the sender's public key means that the holder of the private key created the message. This process relies on the receiver having a copy of the sender's public key and knowing with a high degree of certainty that it really does belong to the sender and not to someone pretending to be the sender. To validate the CA's signature, the receiver must know the CA's public key. Normally, this is handled out-of-band or through an operation performed during the installation of the certificate. For instance, most web browsers are configured with the root certificates of several CAs by default. CA Enrollment process The end host generates a private-public key pair. The end host generates a certificate request, which it forwards to the CA. Manual human intervention is required to approve the enrollment request, which is received by the CA. After the CA operator approves the request, the CA signs the certificate request with its private key and returns the completed certificate to the end host. The end host writes the certificate into a nonvolatile storage area (PC hard disk or NVRAM on Cisco routers). Refer : https://www.ssh.com/manuals/server-zos-product/55/ch06s03s01.html","title":"Ciphers"},{"location":"level101/security/fundamentals/#login-security","text":"","title":"Login Security"},{"location":"level101/security/fundamentals/#ssh","text":"SSH, the Secure Shell, is a popular, powerful, software-based approach to network security. Whenever data is sent by a computer to the network, SSH automatically encrypts (scrambles) it. Then, when the data reaches its intended recipient, SSH automatically decrypts (unscrambles) it. The result is transparent encryption: users can work normally, unaware that their communications are safely encrypted on the network. In addition, SSH can use modern, secure encryption algorithms based on how it's being configured and is effective enough to be found within mission-critical applications at major corporations. SSH has a client/server architecture An SSH server program, typically installed and run by a system administrator, accepts or rejects incoming connections to its host computer. Users then run SSH client programs, typically on other computers, to make requests of the SSH server, such as \u201cPlease log me in,\u201d \u201cPlease send me a file,\u201d or \u201cPlease execute this command.\u201d All communications between clients and servers are securely encrypted and protected from modification. What SSH is not: Although SSH stands for Secure Shell, it is not a true shell in the sense of the Unix Bourne shell and C shell. It is not a command interpreter, nor does it provide wildcard expansion, command history, and so forth. Rather, SSH creates a channel for running a shell on a remote computer, with end-to-end encryption between the two systems. The major features and guarantees of the SSH protocol are: Privacy of your data, via strong encryption Integrity of communications, guaranteeing they haven\u2019t been altered Authentication, i.e., proof of identity of senders and receivers Authorization, i.e., access control to accounts Forwarding or tunnelling to encrypt other TCP/IP-based sessions","title":"SSH"},{"location":"level101/security/fundamentals/#kerberos","text":"According to Greek mythology Kerberos (Cerberus) was the gigantic, three-headed dog that guards the gates of the underworld to prevent the dead from leaving. So when it comes to Computer Science, Kerberos is a network authentication protocol and is currently the default authentication technology used by Microsoft Active Directory to authenticate users to services within a local area network. Kerberos uses symmetric-key cryptography and requires a trusted third-party authentication service to verify user identities. So they used the name of Kerberos for their computer network authentication protocol as the three heads of the Kerberos represent: a client: A user/ a service a server: Kerberos protected hosts reside - a Key Distribution Center (KDC), which acts as the trusted third-party authentication service. The KDC includes the following two servers: Authentication Server (AS) that performs the initial authentication and issues ticket-granting tickets (TGT) for users. Ticket-Granting Server (TGS) that issues service tickets that are based on the initial ticket-granting tickets (TGT).","title":"Kerberos"},{"location":"level101/security/fundamentals/#certificate-chain","text":"The first part of the output of the OpenSSL command shows three certificates numbered 0, 1, and 2(not 2 anymore). Each certificate has a subject, s, and an issuer, i. The first certificate, number 0, is called the end-entity certificate. The subject line tells us it\u2019s valid for any subdomain of google.com because its subject is set to *.google.com. $ openssl s_client -connect www.google.com:443 -CApath /etc/ssl/certs CONNECTED(00000005) depth=2 OU = GlobalSign Root CA - R2, O = GlobalSign, CN = GlobalSign verify return:1 depth=1 C = US, O = Google Trust Services, CN = GTS CA 1O1 verify return:1 depth=0 C = US, ST = California, L = Mountain View, O = Google LLC, CN = www.google.com verify return:1 --- Certificate chain 0 s:/C=US/ST=California/L=Mountain View/O=Google LLC/CN=www.google.com i:/C=US/O=Google Trust Services/CN=GTS CA 1O1 1 s:/C=US/O=Google Trust Services/CN=GTS CA 1O1 i:/OU=GlobalSign Root CA - R2/O=GlobalSign/CN=GlobalSign --- Server certificate The issuer line indicates it\u2019s issued by Google Internet Authority G2, which also happens to be the subject of the second certificate, number 1 What the OpenSSL command line doesn\u2019t show here is the trust store that contains the list of CA certificates trusted by the system OpenSSL runs on. The public certificate of GlobalSign Authority must be present in the system\u2019s trust store to close the verification chain. This is called a chain of trust, and the figure below summarizes its behaviour at a high level. High-level view of the concept of chain of trust applied to verifying the authenticity of a website. The Root CA in the Firefox trust store provides the initial trust to verify the entire chain and trust the end-entity certificate.","title":"Certificate Chain"},{"location":"level101/security/fundamentals/#tls-handshake","text":"The client sends a HELLO message to the server with a list of protocols and algorithms it supports. The server says HELLO back and sends its chain of certificates. Based on the capabilities of the client, the server picks a cipher suite. If the cipher suite supports ephemeral key exchange, like ECDHE does(ECDHE is an algorithm known as the Elliptic Curve Diffie-Hellman Exchange), the server and the client negotiate a pre-master key with the Diffie-Hellman algorithm. The pre-master key is never sent over the wire. The client and server create a session key that will be used to encrypt the data transiting through the connection. At the end of the handshake, both parties possess a secret session key used to encrypt data for the rest of the connection. This is what OpenSSL refers to as Master-Key NOTE There are 3 versions of TLS , TLS 1.0, 1.1 & 1.2 TLS 1.0 was released in 1999, making it a nearly two-decade-old protocol. It has been known to be vulnerable to attacks\u2014such as BEAST and POODLE\u2014for years, in addition to supporting weak cryptography, which doesn\u2019t keep modern-day connections sufficiently secure. TLS 1.1 is the forgotten \u201cmiddle child.\u201d It also has bad cryptography like its younger sibling. In most software, it was leapfrogged by TLS 1.2 and it\u2019s rare to see TLS 1.1 used.","title":"TLS Handshake"},{"location":"level101/security/fundamentals/#perfect-forward-secrecy","text":"The term \u201cephemeral\u201d in the key exchange provides an important security feature mis-named perfect forward secrecy (PFS) or just \u201cForward Secrecy\u201d. In a non-ephemeral key exchange, the client sends the pre-master key to the server by encrypting it with the server\u2019s public key. The server then decrypts the pre-master key with its private key. If at a later point in time, the private key of the server is compromised, an attacker can go back to this handshake, decrypt the pre-master key, obtain the session key, and decrypt the entire traffic. Non-ephemeral key exchanges are vulnerable to attacks that may happen in the future on recorded traffic. And because people seldom change their password, decrypting data from the past may still be valuable for an attacker. An ephemeral key exchange like DHE, or its variant on elliptic curve, ECDHE, solves this problem by not transmitting the pre-master key over the wire. Instead, the pre-master key is computed by both the client and the server in isolation, using nonsensitive information exchanged publicly. Because the pre-master key can\u2019t be decrypted later by an attacker, the session key is safe from future attacks: hence, the term perfect forward secrecy. Keys are changed every X blocks along the stream. That prevents an attacker from simply sniffing the stream and applying brute force to crack the whole thing. \"Forward secrecy\" means that just because I can decrypt block M, does not mean that I can decrypt block Q Downside: The downside to PFS is that all those extra computational steps induce latency on the handshake and slow the user down. To avoid repeating this expensive work at every connection, both sides cache the session key for future use via a technique called session resumption. This is what the session-ID and TLS ticket are for: they allow a client and server that share a session ID to skip over the negotiation of a session key, because they already agreed on one previously, and go directly to exchanging data securely.","title":"\u201cPerfect\u201d Forward Secrecy"},{"location":"level101/security/intro/","text":"Security Prerequisites Linux Basics Linux Networking What to expect from this course The course covers fundamentals of information security along with touching on subjects of system security, network & web security. This course aims to get you familiar with the basics of information security in day to day operations & then as an SRE develop the mindset of ensuring that security takes a front-seat while developing solutions. The course also serves as an introduction to common risks and best practices along with practical ways to find out vulnerable systems and loopholes which might become compromised if not secured. What is not covered under this course The courseware is not an ethical hacking workshop or a very deep dive into the fundamentals of the problems. The course does not deal with hacking or breaking into systems but rather an approach on how to ensure you don\u2019t get into those situations and also to make you aware of different ways a system can be compromised. Course Contents Fundamentals Network Security Threats, Attacks & Defence Writing Secure Code & More Conclusion","title":"Introduction"},{"location":"level101/security/intro/#security","text":"","title":"Security"},{"location":"level101/security/intro/#prerequisites","text":"Linux Basics Linux Networking","title":"Prerequisites"},{"location":"level101/security/intro/#what-to-expect-from-this-course","text":"The course covers fundamentals of information security along with touching on subjects of system security, network & web security. This course aims to get you familiar with the basics of information security in day to day operations & then as an SRE develop the mindset of ensuring that security takes a front-seat while developing solutions. The course also serves as an introduction to common risks and best practices along with practical ways to find out vulnerable systems and loopholes which might become compromised if not secured.","title":"What to expect from this course"},{"location":"level101/security/intro/#what-is-not-covered-under-this-course","text":"The courseware is not an ethical hacking workshop or a very deep dive into the fundamentals of the problems. The course does not deal with hacking or breaking into systems but rather an approach on how to ensure you don\u2019t get into those situations and also to make you aware of different ways a system can be compromised.","title":"What is not covered under this course"},{"location":"level101/security/intro/#course-contents","text":"Fundamentals Network Security Threats, Attacks & Defence Writing Secure Code & More Conclusion","title":"Course Contents"},{"location":"level101/security/network_security/","text":"Part II: Network Security Introduction TCP/IP is the dominant networking technology today. It is a five-layer architecture. These layers are, from top to bottom, the application layer, the transport layer (TCP), the network layer (IP), the data-link layer, and the physical layer. In addition to TCP/IP, there also are other networking technologies. For convenience, we use the OSI network model to represent non-TCP/IP network technologies. Different networks are interconnected using gateways. A gateway can be placed at any layer. The OSI model is a seven-layer architecture. The OSI architecture is similar to the TCP/IP architecture, except that the OSI model specifies two additional layers between the application layer and the transport layer in the TCP/IP architecture. These two layers are the presentation layer and the session layer. Figure 5.1 shows the relationship between the TCP/IP layers and the OSI layers. The application layer in TCP/IP corresponds to the application layer and the presentation layer in OSI. The transport layer in TCP/IP corresponds to the session layer and the transport layer in OSI. The remaining three layers in the TCP/IP architecture are one-to-one correspondent to the remaining three layers in the OSI model. Correspondence between layers of the TCP/IP architecture and the OSI model. Also shown are placements of cryptographic algorithms in network layers, where the dotted arrows indicate actual communications of cryptographic algorithms The functionalities of OSI layers are briefly described as follows: The application layer serves as an interface between applications and network programs. It supports application programs and end-user processing. Common application-layer programs include remote logins, file transfer, email, and Web browsing. The presentation layer is responsible for dealing with data that is formed differently. This protocol layer allows application-layer programs residing on different sides of a communication channel with different platforms to understand each other's data formats regardless of how they are presented. The session layer is responsible for creating, managing, and closing a communication connection. The transport layer is responsible for providing reliable connections, such as packet sequencing, traffic control, and congestion control. The network layer is responsible for routing device-independent data packets from the current hop to the next hop. The data-link layer is responsible for encapsulating device-independent data packets into device-dependent data frames. It has two sublayers: logical link control and media access control. The physical layer is responsible for transmitting device-dependent frames through some physical media. Starting from the application layer, data generated from an application program is passed down layer-by-layer to the physical layer. Data from the previous layer is enclosed in a new envelope at the current layer, where the data from the previous layer is also just an envelope containing the data from the layer before it. This is similar to enclosing a smaller envelope in a larger one. The envelope added at each layer contains sufficient information for handling the packet. Application-layer data are divided into blocks small enough to be encapsulated in an envelope at the next layer. Application data blocks are \u201cdressed up\u201d in the TCP/IP architecture according to the following basic steps. At the sending side, an application data block is encapsulated in a TCP packet when it is passed down to the TCP layer. In other words, a TCP packet consists of a header and a payload, where the header corresponds to the TCP envelope and the payload is the application data block. Likewise, the TCP packet will be encapsulated in an IP packet when it is passed down to the IP layer. An IP packet consists of a header and a payload, which is the TCP packet passed down from the TCP layer. The IP packet will be encapsulated in a device-dependent frame (e.g., an Ethernet frame) when it is passed down to the data-link layer. A frame has a header, and it may also have a trailer. For example, in addition to having a header, an Ethernet frame also has a 32-bit cyclic redundancy check (CRC) trailer. When it is passed down to the physical layer, a frame will be transformed into a sequence of media signals for transmission Flow Diagram of a Packet Generation At the destination side, the medium signals are converted by the physical layer into a frame, which is passed up to the data-link layer. The data-link layer passes the frame payload (i.e., the IP packet encapsulated in the frame) up to the IP layer. The IP layer passes the IP payload, namely, the TCP packet encapsulated in the IP packet, up to the TCP layer. The TCP layer passes the TCP payload, namely, the application data block, up to the application layer. When a packet arrives at a router, it only goes up to the IP layer, where certain fields in the IP header are modified (e.g., the value of TTL is decreased by 1). This modified packet is then passed back down layer-by-layer to the physical layer for further transmission. Public Key Infrastructure To deploy cryptographic algorithms in network applications, we need a way to distribute secret keys using open networks. Public-key cryptography is the best way to distribute these secret keys. To use public-key cryptography, we need to build a public-key infrastructure (PKI) to support and manage public-key certificates and certificate authority (CA) networks. In particular, PKIs are set up to perform the following functions: Determine the legitimacy of users before issuing public-key certificates to them. Issue public-key certificates upon user requests. Extend public-key certificates valid time upon user requests. Revoke public-key certificates upon users' requests or when the corresponding private keys are compromised. Store and manage public-key certificates. Prevent digital signature signers from denying their signatures. Support CA networks to allow different CAs to authenticate public-key certificates issued by other CAs. X.509: https://certificatedecoder.dev/?gclid=EAIaIQobChMI0M731O6G6gIVVSQrCh04bQaAEAAYASAAEgKRkPD_BwE IPsec: A Security Protocol at the Network Layer IPsec is a major security protocol at the network layer IPsec provides a potent platform for constructing virtual private networks (VPN). VPNs are private networks overlayed on public networks. The purpose of deploying cryptographic algorithms at the network layer is to encrypt or authenticate IP packets (either just the payloads or the whole packets). IPsec also specifies how to exchange keys. Thus, IPsec consists of authentication protocols, encryption protocols, and key exchange protocols. They are referred to, respectively, as authentication header (AH), encapsulating security payload (ESP), and Internet key exchange (IKE). PGP & S/MIME : Email Security There are several security protocols at the application layer. The most used of these protocols are email security protocols namely PGP and S/MIME. SMTP (\u201cSimple Mail Transfer Protocol\u201d) is used for sending and delivering from a client to a server via port 25: it\u2019s the outgoing server. On the contrary, POP (\u201cPost Office Protocol\u201d) allows the users to pick up the message and download it into their inbox: it\u2019s the incoming server. The latest version of the Post Office Protocol is named POP3, and it\u2019s been used since 1996; it uses port 110 PGP PGP implements all major cryptographic algorithms, the ZIP compression algorithm, and the Base64 encoding algorithm. It can be used to authenticate a message, encrypt a message, or both. PGP follows the following general process: authentication, ZIP compression, encryption, and Base64 encoding. The Base64 encoding procedure makes the message ready for SMTP transmission GPG (GnuPG) GnuPG is another free encryption standard that companies may use that is based on OpenPGP. GnuPG serves as a replacement for Symantec\u2019s PGP. The main difference is the supported algorithms. However, GnuPG plays nice with PGP by design. Because GnuPG is open, some businesses would prefer the technical support and the user interface that comes with Symantec\u2019s PGP. It is important to note that there are some nuances between the compatibility of GnuPG and PGP, such as the compatibility between certain algorithms, but in most applications such as email, there are workarounds. One such algorithm is the IDEA Module which isn\u2019t included in GnuPG out of the box due to patent issues. S/MIME SMTP can only handle 7-bit ASCII text (You can use UTF-8 extensions to alleviate these limitations, ) messages. While POP can handle other content types besides 7-bit ASCII, POP may, under a common default setting, download all the messages stored in the mail server to the user's local computer. After that, if POP removes these messages from the mail server. This makes it difficult for the users to read their messages from multiple computers. The Multipurpose Internet Mail Extension protocol (MIME) was designed to support sending and receiving email messages in various formats, including nontext files generated by word processors, graphics files, sound files, and video clips. Moreover, MIME allows a single message to include mixed types of data in any combination of these formats. The Internet Mail Access Protocol (IMAP), operated on TCP port 143(only for non-encrypted), stores (Configurable on both server & client just like PoP) incoming email messages in the mail server until the user deletes them deliberately. This allows the users to access their mailbox from multiple machines and download messages to a local machine without deleting it from the mailbox in the mail server. SSL/TLS SSL uses a PKI to decide if a server\u2019s public key is trustworthy by requiring servers to use a security certificate signed by a trusted CA. When Netscape Navigator 1.0 was released, it trusted a single CA operated by the RSA Data Security corporation. The server\u2019s public RSA keys were used to be stored in the security certificate, which can then be used by the browser to establish a secure communication channel. The security certificates we use today still rely on the same standard (named X.509) that Netscape Navigator 1.0 used back then. Netscape intended to train users(though this didn\u2019t work out later) to differentiate secure communications from insecure ones, so they put a lock icon next to the address bar. When the lock is open, the communication is insecure. A closed lock means communication has been secured with SSL, which required the server to provide a signed certificate. You\u2019re obviously familiar with this icon as it\u2019s been in every browser ever since. The engineers at Netscape truly created a standard for secure internet communications. A year after releasing SSL 2.0, Netscape fixed several security issues and released SSL 3.0, a protocol that, albeit being officially deprecated since June 2015, remains in use in certain parts of the world more than 20 years after its introduction. To standardize SSL, the Internet Engineering Task Force (IETF) created a slightly modified SSL 3.0 and, in 1999, unveiled it as Transport Layer Security (TLS) 1.0. The name change between SSL and TLS continues to confuse people today. Officially, TLS is the new SSL, but in practice, people use SSL and TLS interchangeably to talk about any version of the protocol. Must See: https://tls.ulfheim.net/ https://davidwong.fr/tls13/ Network Perimeter Security Let us see how we keep a check on the perimeter i.e the edges, the first layer of protection General Firewall Framework Firewalls are needed because encryption algorithms cannot effectively stop malicious packets from getting into an edge network. This is because IP packets, regardless of whether they are encrypted, can always be forwarded into an edge network. Firewalls that were developed in the 1990s are important instruments to help restrict network access. A firewall may be a hardware device, a software package, or a combination of both. Packets flowing into the internal network from the outside should be evaluated before they are allowed to enter. One of the critical elements of a firewall is its ability to examine packets without imposing a negative impact on communication speed while providing security protections for the internal network. The packet inspection that is carried out by firewalls can be done using several different methods. Based on the particular method used by the firewall, it can be characterized as either a packet filter, circuit gateway, application gateway, or dynamic packet filter. Packet Filters It inspects ingress packets coming to an internal network from outside and inspects egress packets going outside from an internal network Packing filtering only inspects IP headers and TCP headers, not the payloads generated at the application layer A packet-filtering firewall uses a set of rules to determine whether a packet should be allowed or denied to pass through. 2 types: Stateless It treats each packet as an independent object, and it does not keep track of any previously processed packets. In other words, stateless filtering inspects a packet when it arrives and makes a decision without leaving any record of the packet being inspected. Stateful Stateful filtering, also referred to as connection-state filtering, keeps track of connections between an internal host and an external host. A connection state (or state, for short) indicates whether it is a TCP connection or a UDP connection and whether the connection is established. Circuit Gateways Circuit gateways, also referred to as circuit-level gateways, are typically operated at the transportation layer They evaluate the information of the IP addresses and the port numbers contained in TCP (or UDP) headers and use it to determine whether to allow or to disallow an internal host and an external host to establish a connection. It is common practice to combine packet filters and circuit gateways to form a dynamic packet filter (DPF). Application Gateways(ALG) Aka PROXY Servers An Application Level Gateway (ALG) acts as a proxy for internal hosts, processing service requests from external clients. An ALG performs deep inspections on each IP packet (ingress or egress). In particular, an ALG inspects application program formats contained in the packet (e.g., MIME format or SQL format) and examines whether its payload is permitted. Thus, an ALG may be able to detect a computer virus contained in the payload. Because an ALG inspects packet payloads, it may be able to detect malicious code and quarantine suspicious packets, in addition to blocking packets with suspicious IP addresses and TCP ports. On the other hand, an ALG also incurs substantial computation and space overheads. Trusted Systems & Bastion Hosts A Trusted Operating System (TOS) is an operating system that meets a particular set of security requirements. Whether an operating system can be trusted or not depends on several elements. For example, for an operating system on a particular computer to be certified trusted, one needs to validate that, among other things, the following four requirements are satisfied: Its system design contains no defects; Its system software contains no loopholes; Its system is configured properly; and Its system management is appropriate. Bastion Hosts Bastion hosts are computers with strong defence mechanisms. They often serve as host computers for implementing application gateways, circuit gateways, and other types of firewalls. A bastion host is operated on a trusted operating system that must not contain unnecessary functionalities or programs. This measure helps to reduce error probabilities and makes it easier to conduct security checks. Only those network application programs that are necessary, for example, SSH, DNS, SMTP, and authentication programs, are installed on a bastion host. Bastion hosts are also primarily used as controlled ingress points so that the security monitoring can focus more narrowly on actions happening at a single point closely. Common Techniques & Scannings, Packet Capturing Scanning Ports with Nmap Nmap (\"Network Mapper\") is a free and open-source (license) utility for network discovery and security auditing. Many systems and network administrators also find it useful for tasks such as network inventory, managing service upgrade schedules, and monitoring host or service uptime. The best thing about Nmap is it\u2019s free and open-source and is very flexible and versatile Nmap is often used to determine alive hosts in a network, open ports on those hosts, services running on those open ports, and version identification of that service on that port. More at http://scanme.nmap.org/ nmap [scan type] [options] [target specification] Nmap uses 6 different port states: Open \u2014 An open port is one that is actively accepting TCP, UDP or SCTP connections. Open ports are what interests us the most because they are the ones that are vulnerable to attacks. Open ports also show the available services on a network. Closed \u2014 A port that receives and responds to Nmap probe packets but there is no application listening on that port. Useful for identifying that the host exists and for OS detection. Filtered \u2014 Nmap can\u2019t determine whether the port is open because packet filtering prevents its probes from reaching the port. Filtering could come from firewalls or router rules. Often little information is given from filtered ports during scans as the filters can drop the probes without responding or respond with useless error messages e.g. destination unreachable. Unfiltered \u2014 Port is accessible but Nmap doesn\u2019t know if it is open or closed. Only used in ACK scan which is used to map firewall rulesets. Other scan types can be used to identify whether the port is open. Open/filtered \u2014 Nmap is unable to determine between open and filtered. This happens when an open port gives no response. No response could mean that the probe was dropped by a packet filter or any response is blocked. Closed/filtered \u2014 Nmap is unable to determine whether a port is closed or filtered. Only used in the IP ID idle scan. Types of Nmap Scan: TCP Connect TCP Connect scan completes the 3-way handshake. If a port is open, the operating system completes the TCP three-way handshake and the port scanner immediately closes the connection to avoid DOS. This is \u201cnoisy\u201d because the services can log the sender IP address and might trigger Intrusion Detection Systems. UDP Scan This scan checks to see if any UDP ports are listening. Since UDP does not respond with a positive acknowledgement like TCP and only responds to an incoming UDP packet when the port is closed, SYN Scan SYN scan is another form of TCP scanning. This scan type is also known as \u201chalf-open scanning\u201d because it never actually opens a full TCP connection. The port scanner generates a SYN packet. If the target port is open, it will respond with an SYN-ACK packet. The scanner host responds with an RST packet, closing the connection before the handshake is completed. If the port is closed but unfiltered, the target will instantly respond with an RST packet. SYN scan has the advantage that the individual services never actually receive a connection. FIN Scan This is a stealthy scan, like the SYN scan, but sends a TCP FIN packet instead. ACK Scan Ack scanning determines whether the port is filtered or not. Null Scan Another very stealthy scan that sets all the TCP header flags to off or null. This is not normally a valid packet and some hosts will not know what to do with this. XMAS Scan Similar to the NULL scan except for all the flags in the TCP header is set to on RPC Scan This special type of scan looks for machine answering to RPC (Remote Procedure Call) services IDLE Scan It is a super stealthy method whereby the scan packets are bounced off an external host. You don\u2019t need to have control over the other host but it does have to set up and meet certain requirements. You must input the IP address of our \u201czombie\u201d host and what port number to use. It is one of the more controversial options in Nmap since it only has a use for malicious attacks. Scan Techniques A couple of scan techniques which can be used to gain more information about a system and its ports. You can read more at https://medium.com/infosec-adventures/nmap-cheatsheet-a423fcdda0ca OpenVAS OpenVAS is a full-featured vulnerability scanner. OpenVAS is a framework of services and tools that provides a comprehensive and powerful vulnerability scanning and management package OpenVAS, which is an open-source program, began as a fork of the once-more-popular scanning program, Nessus. OpenVAS is made up of three main parts. These are: a regularly updated feed of Network Vulnerability Tests (NVTs); a scanner, which runs the NVTs; and an SQLite 3 database for storing both your test configurations and the NVTs\u2019 results and configurations. https://www.greenbone.net/en/install_use_gce/ WireShark Wireshark is a protocol analyzer. This means Wireshark is designed to decode not only packet bits and bytes but also the relations between packets and protocols. Wireshark understands protocol sequences. A simple demo of Wireshark Capture only udp packets: Capture filter = \u201cudp\u201d Capture only tcp packets Capture filter = \u201ctcp\u201d TCP/IP 3 way Handshake Filter by IP address: displays all traffic from IP, be it source or destination ip.addr == 192.168.1.1 Filter by source address: display traffic only from IP source ip.src == 192.168.0.1 Filter by destination: display traffic only form IP destination ip.dst == 192.168.0.1 Filter by IP subnet: display traffic from subnet, be it source or destination ip.addr = 192.168.0.1/24 Filter by protocol: filter traffic by protocol name dns http ftp arp ssh telnet icmp Exclude IP address: remove traffic from and to IP address !ip.addr ==192.168.0.1 Display traffic between two specific subnet ip.addr == 192.168.0.1/24 and ip.addr == 192.168.1.1/24 Display traffic between two specific workstations ip.addr == 192.168.0.1 and ip.addr == 192.168.0.2 Filter by MAC eth.addr = 00:50:7f:c5:b6:78 Filter TCP port tcp.port == 80 Filter TCP port source tcp.srcport == 80 Filter TCP port destination tcp.dstport == 80 Find user agents http.user_agent contains Firefox !http.user_agent contains || !http.user_agent contains Chrome Filter broadcast traffic !(arp or icmp or dns) Filter IP address and port tcp.port == 80 && ip.addr == 192.168.0.1 Filter all http get requests http.request Filter all http get requests and responses http.request or http.response Filter three way handshake tcp.flags.syn==1 or (tcp.seq==1 and tcp.ack==1 and tcp.len==0 and tcp.analysis.initial_rtt) Find files by type frame contains \u201c(attachment|tar|exe|zip|pdf)\u201d Find traffic based on keyword tcp contains facebook frame contains facebook Detecting SYN Floods tcp.flags.syn == 1 and tcp.flags.ack == 0 Wireshark Promiscuous Mode - By default, Wireshark only captures packets going to and from the computer where it runs. By checking the box to run Wireshark in Promiscuous Mode in the Capture Settings, you can capture most of the traffic on the LAN. DumpCap Dumpcap is a network traffic dump tool. It captures packet data from a live network and writes the packets to a file. Dumpcap\u2019s native capture file format is pcapng, which is also the format used by Wireshark. By default, Dumpcap uses the pcap library to capture traffic from the first available network interface and writes the received raw packet data, along with the packets\u2019 time stamps into a pcapng file. The capture filter syntax follows the rules of the pcap library. The Wireshark command-line utility called 'dumpcap.exe' can be used to capture LAN traffic over an extended period of time. Wireshark itself can also be used, but dumpcap does not significantly utilize the computer's memory while capturing for long periods. DaemonLogger Daemonlogger is a packet logging application designed specifically for use in Network and Systems Management (NSM) environments. The biggest benefit Daemonlogger provides is that, like Dumpcap, it is simple to use for capturing packets. In order to begin capturing, you need only to invoke the command and specify an interface. daemonlogger \u2013i eth1 This option, by default, will begin capturing packets and logging them to the current working directory. Packets will be collected until the capture file size reaches 2 GB, and then a new file will be created. This will continue indefinitely until the process is halted. NetSniff-NG Netsniff-NG is a high-performance packet capture utility While the utilities we\u2019ve discussed to this point rely on Libpcap for capture, Netsniff-NG utilizes zero-copy mechanisms to capture packets. This is done with the intent to support full packet capture over high throughput links. To begin capturing packets with Netsniff-NG, we have to specify an input and output. In most cases, the input will be a network interface, and the output will be a file or folder on disk. netsniff-ng \u2013i eth1 \u2013o data.pcap Netflow NetFlow is a feature that was introduced on Cisco routers around 1996 that provides the ability to collect IP network traffic as it enters or exits an interface. By analyzing the data provided by NetFlow, a network administrator can determine things such as the source and destination of traffic, class of service, and the causes of congestion. A typical flow monitoring setup (using NetFlow) consists of three main components:[1] Flow exporter: aggregates packets into flows and exports flow records towards one or more flow collectors. Flow collector: responsible for reception, storage and pre-processing of flow data received from a flow exporter. Analysis application: analyzes received flow data in the context of intrusion detection or traffic profiling, for example. Routers and switches that support NetFlow can collect IP traffic statistics on all interfaces where NetFlow is enabled, and later export those statistics as NetFlow records toward at least one NetFlow collector\u2014typically a server that does the actual traffic analysis. IDS A security solution that detects security-related events in your environment but does not block them. IDS sensors can be software and hardware-based used to collect and analyze the network traffic. These sensors are available in two varieties, network IDS and host IDS. A host IDS is a server-specific agent running on a server with a minimum of overhead to monitor the operating system. A network IDS can be embedded in a networking device, a standalone appliance, or a module monitoring the network traffic. Signature Based IDS The signature-based IDS monitors the network traffic or observes the system and sends an alarm if a known malicious event is happening. It does so by comparing the data flow against a database of known attack patterns These signatures explicitly define what traffic or activity should be considered as malicious. Signature-based detection has been the bread and butter of network-based defensive security for over a decade, partially because it is very similar to how malicious activity is detected at the host level with antivirus utilities The formula is fairly simple: an analyst observes a malicious activity, derives indicators from the activity and develops them into signatures, and then those signatures will alert whenever the activity occurs again. ex: SNORT & SURICATA Policy-Based IDS The policy-based IDSs (mainly host IDSs) trigger an alarm whenever a violation occurs against the configured policy. This configured policy is or should be a representation of the security policies. This type of IDS is flexible and can be customized to a company's network requirements because it knows exactly what is permitted and what is not. On the other hand, the signature-based systems rely on vendor specifics and default settings. Anomaly Based IDS The anomaly-based IDS looks for traffic that deviates from the normal, but the definition of what is a normal network traffic pattern is the tricky part Two types of anomaly-based IDS exist: statistical and nonstatistical anomaly detection Statistical anomaly detection learns the traffic patterns interactively over a period of time. In the nonstatistical approach, the IDS has a predefined configuration of the supposedly acceptable and valid traffic patterns. Host-Based IDS & Network-Based IDS A host IDS can be described as a distributed agent residing on each server of the network that needs protection. These distributed agents are tied very closely to the underlying operating system. Network IDSs, on the other hand, can be described as intelligent sniffing devices. Data (raw packets) is captured from the network by a network IDS, whereas host IDSs capture the data from the host on which they are installed. Honeypots The use of decoy machines to direct intruders' attention away from the machines under protection is a major technique to preclude intrusion attacks. Any device, system, directory, or file used as a decoy to lure attackers away from important assets and to collect intrusion or abusive behaviours is referred to as a honeypot. A honeypot may be implemented as a physical device or as an emulation system. The idea is to set up decoy machines in a LAN, or decoy directories/files in a file system and make them appear important, but with several exploitable loopholes, to lure attackers to attack these machines or directories/files, so that other machines, directories, and files can evade intruders' attentions. A decoy machine may be a host computer or a server computer. Likewise, we may also set up decoy routers or even decoy LANs. Chinks In The Armour (TCP/IP Security Issues) IP Spoofing In this type of attack, the attacker replaces the IP address of the sender, or in some rare cases the destination, with a different address. IP spoofing is normally used to exploit a target host. In other cases, it is used to start a denial-of-service (DoS) attack. In a DoS attack, an attacker modifies the IP packet to mislead the target host into accepting the original packet as a packet sourced at a trusted host. The attacker must know the IP address of the trusted host to modify the packet headers (source IP address) so that it appears that the packets are coming from that host. IP Spoofing Detection Techniques Direct TTL Probes In this technique we send a packet to a host of suspect spoofed IP that triggers reply and compares TTL with suspect packet; if the TTL in the reply is not the same as the packet being checked; it is a spoofed packet. This Technique is successful when the attacker is in a different subnet from the victim. IP Identification Number. Send a probe to the host of suspect spoofed traffic that triggers a reply and compares IP ID with suspect traffic. If IP IDs are not in the near value of packet being checked, suspect traffic is spoofed TCP Flow Control Method Attackers sending spoofed TCP packets will not receive the target\u2019s SYN-ACK packets. Attackers cannot, therefore, be responsive to change in the congestion window size When the receiver still receives traffic even after a windows size is exhausted, most probably the packets are spoofed. Covert Channel A covert or clandestine channel can be best described as a pipe or communication channel between two entities that can be exploited by a process or application transferring information in a manner that violates the system's security specifications. More specifically for TCP/IP, in some instances, covert channels are established, and data can be secretly passed between two end systems. Ex: ICMP resides at the Internet layer of the TCP/IP protocol suite and is implemented in all TCP/IP hosts. Based on the specifications of the ICMP Protocol, an ICMP Echo Request message should have an 8-byte header and a 56-byte payload. The ICMP Echo Request packet should not carry any data in the payload. However, these packets are often used to carry secret information. The ICMP packets are altered slightly to carry secret data in the payload. This makes the size of the packet larger, but no control exists in the protocol stack to defeat this behaviour. The alteration of ICMP packets allows intruders to program specialized client-server pairs. These small pieces of code export confidential information without alerting the network administrator. ICMP can be leveraged for more than data exfiltration. For eg. some C&C tools such as Loki used ICMP channel to establish encrypted interactive session back in 1996. Deep packet inspection has since come a long way. A lot of IDS/IPS detect ICMP tunnelling. Check for echo responses that do not contain the same payload as request Check for the volume of ICMP traffic especially for volumes beyond an acceptable threshold IP Fragmentation Attack The TCP/IP protocol suite, or more specifically IP, allows the fragmentation of packets.(this is a feature & not a bug) IP fragmentation offset is used to keep track of the different parts of a datagram. The information or content in this field is used at the destination to reassemble the datagrams All such fragments have the same Identification field value, and the fragmentation offset indicates the position of the current fragment in the context of the original packet. Many access routers and firewalls do not perform packet reassembly. In normal operation, IP fragments do not overlap, but attackers can create artificially fragmented packets to mislead the routers or firewalls. Usually, these packets are small and almost impractical for end systems because of data and computational overhead. A good example of an IP fragmentation attack is the Ping of Death attack. The Ping of Death attack sends fragments that, when reassembled at the end station, create a larger packet than the maximum permissible length. TCP Flags Data exchange using TCP does not happen until a three-way handshake has been completed. This handshake uses different flags to influence the way TCP segments are processed. There are 6 bits in the TCP header that are often called flags. Namely: 6 different flags are part of the TCP header: Urgent pointer field (URG), Acknowledgment field (ACK), Push function (PSH), Reset the connection (RST), Synchronize sequence numbers (SYN), and the sender is finished with this connection (FIN). Abuse of the normal operation or settings of these flags can be used by attackers to launch DoS attacks. This causes network servers or web servers to crash or hang. | SYN | FIN | PSH | RST | Validity| |------|------|-------|------|---------| | 1 |1 |0 |0 |Illegal Combination | 1 |1 |1 |0 |Illegal Combination | 1 |1 |0 |1 |Illegal Combination | 1 |1 |1 |1 |Illegal Combination The attacker's ultimate goal is to write special programs or pieces of code that can construct these illegal combinations resulting in an efficient DoS attack. SYN FLOOD The timers (or lack of certain timers) in 3 way handshake are often used and exploited by attackers to disable services or even to enter systems. After step 2 of the three-way handshake, no limit is set on the time to wait after receiving a SYN. The attacker initiates many connection requests to the webserver of Company XYZ (almost certainly with a spoofed IP address). The SYN+ACK packets (Step 2) sent by the web server back to the originating source IP address are not replied to. This leaves a TCP session half-open on the webserver. Multiple packets cause multiple TCP sessions to stay open. Based on the hardware limitations of the server, a limited number of TCP sessions can stay open, and as a result, the webserver refuses further connection establishments attempts from any host as soon as a certain limit is reached. These half-open connections need to be completed or timed out before new connections can be established. FIN Attack In normal operation, the sender sets the TCP FIN flag indicating that no more data will be transmitted and the connection can be closed down. This is a four-way handshake mechanism, with both sender and receiver expected to send an acknowledgement on a received FIN packet. During an attack that is trying to kill connections, a spoofed FIN packet is constructed. This packet also has the correct sequence number, so the packets are seen as valid by the targeted host. These sequence numbers are easy to predict. This process is referred to as TCP sequence number prediction, whereby the attacker either sniffs the current Sequence and Acknowledgment (SEQ/ACK) numbers of the connection or can algorithmically predict these numbers. Connection Hijacking An authorized user (Employee X) sends HTTP requests over a TCP session with the webserver. The web server accepts the packets from Employee X only when the packet has the correct SEQ/ACK numbers. As seen previously, these numbers are important for the webserver to distinguish between different sessions and to make sure it is still talking to Employee X. Imagine that the cracker starts sending packets to the web server spoofing the IP address of Employee X, using the correct SEQ/ACK combination. The web server accepts the packet and increments the ACK number. In the meantime, Employee X continues to send packets but with incorrect SEQ/ACK numbers. As a result of sending unsynchronized packets, all data from Employee X is discarded when received by the webserver. The attacker pretends to be Employee X using the correct numbers. This finally results in the cracker hijacking the connection, whereby Employee X is completely confused and the webserver replies assuming the cracker is sending correct synchronized data. STEPS: The attacker examines the traffic flows with a network monitor and notices traffic from Employee X to a web server. The web server returns or echoes data back to the origination station (Employee X). Employee X acknowledges the packet. The cracker launches a spoofed packet to the server. The web server responds to the cracker. The cracker starts verifying SEQ/ACK numbers to double-check success. At this time, the cracker takes over the session from Employee X, which results in a session hanging for Employee X. The cracker can start sending traffic to the webserver. The web server returns the requested data to confirm delivery with the correct ACK number. The cracker can continue to send data (keeping track of the correct SEQ/ACK numbers) until eventually setting the FIN flag to terminate the session. Buffer Overflow A buffer is a temporary data storage area used to store program code and data. When a program or process tries to store more data in a buffer than it was originally anticipated to hold, a buffer overflow occurs. Buffers are temporary storage locations in memory (memory or buffer sizes are often measured in bytes) that can store a fixed amount of data in bytes. When more data is retrieved than can be stored in a buffer location, the additional information must go into an adjacent buffer, resulting in overwriting the valid data held in them. Mechanism: Buffer overflow vulnerabilities exist in different types. But the overall goal for all buffer overflow attacks is to take over the control of a privileged program and, if possible, the host. The attacker has two tasks to achieve this goal. First, the dirty code needs to be available in the program's code address space. Second, the privileged program should jump to that particular part of the code, which ensures that the proper parameters are loaded into memory. The first task can be achieved in two ways: by injecting the code in the right address space or by using the existing code and modifying certain parameters slightly. The second task is a little more complex because the program's control flow needs to be modified to make the program jump to the dirty code. CounterMeasure: The most important approach is to have a concerted focus on writing correct code. A second method is to make the data buffers (memory locations) address space of the program code non-executable. This type of address space makes it impossible to execute code, which might be infiltrated in the program's buffers during an attack. More Spoofing Address Resolution Protocol Spoofing The Address Resolution Protocol (ARP) provides a mechanism to resolve, or map, a known IP address to a MAC sublayer address. Using ARP spoofing, the cracker can exploit this hardware address authentication mechanism by spoofing the hardware address of Host B. Basically, the attacker can convince any host or network device on the local network that the cracker's workstation is the host to be trusted. This is a common method used in a switched environment. ARP spoofing can be prevented with the implementation of static ARP tables in all the hosts and routers of your network. Alternatively, you can implement an ARP server that responds to ARP requests on behalf of the target host. DNS Spoofing DNS spoofing is the method whereby the hacker convinces the target machine that the system it wants to connect to is the machine of the cracker. The cracker modifies some records so that name entries of hosts correspond to the attacker's IP address. There have been instances in which the complete DNS server was compromised by an attack. To counter DNS spoofing, the reverse lookup detects these attacks. The reverse lookup is a mechanism to verify the IP address against a name. The IP address and name files are usually kept on different servers to make compromise much more difficult","title":"Network Security"},{"location":"level101/security/network_security/#part-ii-network-security","text":"","title":"Part II: Network Security"},{"location":"level101/security/network_security/#introduction","text":"TCP/IP is the dominant networking technology today. It is a five-layer architecture. These layers are, from top to bottom, the application layer, the transport layer (TCP), the network layer (IP), the data-link layer, and the physical layer. In addition to TCP/IP, there also are other networking technologies. For convenience, we use the OSI network model to represent non-TCP/IP network technologies. Different networks are interconnected using gateways. A gateway can be placed at any layer. The OSI model is a seven-layer architecture. The OSI architecture is similar to the TCP/IP architecture, except that the OSI model specifies two additional layers between the application layer and the transport layer in the TCP/IP architecture. These two layers are the presentation layer and the session layer. Figure 5.1 shows the relationship between the TCP/IP layers and the OSI layers. The application layer in TCP/IP corresponds to the application layer and the presentation layer in OSI. The transport layer in TCP/IP corresponds to the session layer and the transport layer in OSI. The remaining three layers in the TCP/IP architecture are one-to-one correspondent to the remaining three layers in the OSI model. Correspondence between layers of the TCP/IP architecture and the OSI model. Also shown are placements of cryptographic algorithms in network layers, where the dotted arrows indicate actual communications of cryptographic algorithms The functionalities of OSI layers are briefly described as follows: The application layer serves as an interface between applications and network programs. It supports application programs and end-user processing. Common application-layer programs include remote logins, file transfer, email, and Web browsing. The presentation layer is responsible for dealing with data that is formed differently. This protocol layer allows application-layer programs residing on different sides of a communication channel with different platforms to understand each other's data formats regardless of how they are presented. The session layer is responsible for creating, managing, and closing a communication connection. The transport layer is responsible for providing reliable connections, such as packet sequencing, traffic control, and congestion control. The network layer is responsible for routing device-independent data packets from the current hop to the next hop. The data-link layer is responsible for encapsulating device-independent data packets into device-dependent data frames. It has two sublayers: logical link control and media access control. The physical layer is responsible for transmitting device-dependent frames through some physical media. Starting from the application layer, data generated from an application program is passed down layer-by-layer to the physical layer. Data from the previous layer is enclosed in a new envelope at the current layer, where the data from the previous layer is also just an envelope containing the data from the layer before it. This is similar to enclosing a smaller envelope in a larger one. The envelope added at each layer contains sufficient information for handling the packet. Application-layer data are divided into blocks small enough to be encapsulated in an envelope at the next layer. Application data blocks are \u201cdressed up\u201d in the TCP/IP architecture according to the following basic steps. At the sending side, an application data block is encapsulated in a TCP packet when it is passed down to the TCP layer. In other words, a TCP packet consists of a header and a payload, where the header corresponds to the TCP envelope and the payload is the application data block. Likewise, the TCP packet will be encapsulated in an IP packet when it is passed down to the IP layer. An IP packet consists of a header and a payload, which is the TCP packet passed down from the TCP layer. The IP packet will be encapsulated in a device-dependent frame (e.g., an Ethernet frame) when it is passed down to the data-link layer. A frame has a header, and it may also have a trailer. For example, in addition to having a header, an Ethernet frame also has a 32-bit cyclic redundancy check (CRC) trailer. When it is passed down to the physical layer, a frame will be transformed into a sequence of media signals for transmission Flow Diagram of a Packet Generation At the destination side, the medium signals are converted by the physical layer into a frame, which is passed up to the data-link layer. The data-link layer passes the frame payload (i.e., the IP packet encapsulated in the frame) up to the IP layer. The IP layer passes the IP payload, namely, the TCP packet encapsulated in the IP packet, up to the TCP layer. The TCP layer passes the TCP payload, namely, the application data block, up to the application layer. When a packet arrives at a router, it only goes up to the IP layer, where certain fields in the IP header are modified (e.g., the value of TTL is decreased by 1). This modified packet is then passed back down layer-by-layer to the physical layer for further transmission.","title":"Introduction"},{"location":"level101/security/network_security/#public-key-infrastructure","text":"To deploy cryptographic algorithms in network applications, we need a way to distribute secret keys using open networks. Public-key cryptography is the best way to distribute these secret keys. To use public-key cryptography, we need to build a public-key infrastructure (PKI) to support and manage public-key certificates and certificate authority (CA) networks. In particular, PKIs are set up to perform the following functions: Determine the legitimacy of users before issuing public-key certificates to them. Issue public-key certificates upon user requests. Extend public-key certificates valid time upon user requests. Revoke public-key certificates upon users' requests or when the corresponding private keys are compromised. Store and manage public-key certificates. Prevent digital signature signers from denying their signatures. Support CA networks to allow different CAs to authenticate public-key certificates issued by other CAs. X.509: https://certificatedecoder.dev/?gclid=EAIaIQobChMI0M731O6G6gIVVSQrCh04bQaAEAAYASAAEgKRkPD_BwE","title":"Public Key Infrastructure"},{"location":"level101/security/network_security/#ipsec-a-security-protocol-at-the-network-layer","text":"IPsec is a major security protocol at the network layer IPsec provides a potent platform for constructing virtual private networks (VPN). VPNs are private networks overlayed on public networks. The purpose of deploying cryptographic algorithms at the network layer is to encrypt or authenticate IP packets (either just the payloads or the whole packets). IPsec also specifies how to exchange keys. Thus, IPsec consists of authentication protocols, encryption protocols, and key exchange protocols. They are referred to, respectively, as authentication header (AH), encapsulating security payload (ESP), and Internet key exchange (IKE).","title":"IPsec: A Security Protocol at the Network Layer"},{"location":"level101/security/network_security/#pgp-smime-email-security","text":"There are several security protocols at the application layer. The most used of these protocols are email security protocols namely PGP and S/MIME. SMTP (\u201cSimple Mail Transfer Protocol\u201d) is used for sending and delivering from a client to a server via port 25: it\u2019s the outgoing server. On the contrary, POP (\u201cPost Office Protocol\u201d) allows the users to pick up the message and download it into their inbox: it\u2019s the incoming server. The latest version of the Post Office Protocol is named POP3, and it\u2019s been used since 1996; it uses port 110 PGP PGP implements all major cryptographic algorithms, the ZIP compression algorithm, and the Base64 encoding algorithm. It can be used to authenticate a message, encrypt a message, or both. PGP follows the following general process: authentication, ZIP compression, encryption, and Base64 encoding. The Base64 encoding procedure makes the message ready for SMTP transmission GPG (GnuPG) GnuPG is another free encryption standard that companies may use that is based on OpenPGP. GnuPG serves as a replacement for Symantec\u2019s PGP. The main difference is the supported algorithms. However, GnuPG plays nice with PGP by design. Because GnuPG is open, some businesses would prefer the technical support and the user interface that comes with Symantec\u2019s PGP. It is important to note that there are some nuances between the compatibility of GnuPG and PGP, such as the compatibility between certain algorithms, but in most applications such as email, there are workarounds. One such algorithm is the IDEA Module which isn\u2019t included in GnuPG out of the box due to patent issues. S/MIME SMTP can only handle 7-bit ASCII text (You can use UTF-8 extensions to alleviate these limitations, ) messages. While POP can handle other content types besides 7-bit ASCII, POP may, under a common default setting, download all the messages stored in the mail server to the user's local computer. After that, if POP removes these messages from the mail server. This makes it difficult for the users to read their messages from multiple computers. The Multipurpose Internet Mail Extension protocol (MIME) was designed to support sending and receiving email messages in various formats, including nontext files generated by word processors, graphics files, sound files, and video clips. Moreover, MIME allows a single message to include mixed types of data in any combination of these formats. The Internet Mail Access Protocol (IMAP), operated on TCP port 143(only for non-encrypted), stores (Configurable on both server & client just like PoP) incoming email messages in the mail server until the user deletes them deliberately. This allows the users to access their mailbox from multiple machines and download messages to a local machine without deleting it from the mailbox in the mail server. SSL/TLS SSL uses a PKI to decide if a server\u2019s public key is trustworthy by requiring servers to use a security certificate signed by a trusted CA. When Netscape Navigator 1.0 was released, it trusted a single CA operated by the RSA Data Security corporation. The server\u2019s public RSA keys were used to be stored in the security certificate, which can then be used by the browser to establish a secure communication channel. The security certificates we use today still rely on the same standard (named X.509) that Netscape Navigator 1.0 used back then. Netscape intended to train users(though this didn\u2019t work out later) to differentiate secure communications from insecure ones, so they put a lock icon next to the address bar. When the lock is open, the communication is insecure. A closed lock means communication has been secured with SSL, which required the server to provide a signed certificate. You\u2019re obviously familiar with this icon as it\u2019s been in every browser ever since. The engineers at Netscape truly created a standard for secure internet communications. A year after releasing SSL 2.0, Netscape fixed several security issues and released SSL 3.0, a protocol that, albeit being officially deprecated since June 2015, remains in use in certain parts of the world more than 20 years after its introduction. To standardize SSL, the Internet Engineering Task Force (IETF) created a slightly modified SSL 3.0 and, in 1999, unveiled it as Transport Layer Security (TLS) 1.0. The name change between SSL and TLS continues to confuse people today. Officially, TLS is the new SSL, but in practice, people use SSL and TLS interchangeably to talk about any version of the protocol. Must See: https://tls.ulfheim.net/ https://davidwong.fr/tls13/","title":"PGP & S/MIME : Email Security"},{"location":"level101/security/network_security/#network-perimeter-security","text":"Let us see how we keep a check on the perimeter i.e the edges, the first layer of protection","title":"Network Perimeter Security"},{"location":"level101/security/network_security/#general-firewall-framework","text":"Firewalls are needed because encryption algorithms cannot effectively stop malicious packets from getting into an edge network. This is because IP packets, regardless of whether they are encrypted, can always be forwarded into an edge network. Firewalls that were developed in the 1990s are important instruments to help restrict network access. A firewall may be a hardware device, a software package, or a combination of both. Packets flowing into the internal network from the outside should be evaluated before they are allowed to enter. One of the critical elements of a firewall is its ability to examine packets without imposing a negative impact on communication speed while providing security protections for the internal network. The packet inspection that is carried out by firewalls can be done using several different methods. Based on the particular method used by the firewall, it can be characterized as either a packet filter, circuit gateway, application gateway, or dynamic packet filter.","title":"General Firewall Framework"},{"location":"level101/security/network_security/#packet-filters","text":"It inspects ingress packets coming to an internal network from outside and inspects egress packets going outside from an internal network Packing filtering only inspects IP headers and TCP headers, not the payloads generated at the application layer A packet-filtering firewall uses a set of rules to determine whether a packet should be allowed or denied to pass through. 2 types: Stateless It treats each packet as an independent object, and it does not keep track of any previously processed packets. In other words, stateless filtering inspects a packet when it arrives and makes a decision without leaving any record of the packet being inspected. Stateful Stateful filtering, also referred to as connection-state filtering, keeps track of connections between an internal host and an external host. A connection state (or state, for short) indicates whether it is a TCP connection or a UDP connection and whether the connection is established.","title":"Packet Filters"},{"location":"level101/security/network_security/#circuit-gateways","text":"Circuit gateways, also referred to as circuit-level gateways, are typically operated at the transportation layer They evaluate the information of the IP addresses and the port numbers contained in TCP (or UDP) headers and use it to determine whether to allow or to disallow an internal host and an external host to establish a connection. It is common practice to combine packet filters and circuit gateways to form a dynamic packet filter (DPF).","title":"Circuit Gateways"},{"location":"level101/security/network_security/#application-gatewaysalg","text":"Aka PROXY Servers An Application Level Gateway (ALG) acts as a proxy for internal hosts, processing service requests from external clients. An ALG performs deep inspections on each IP packet (ingress or egress). In particular, an ALG inspects application program formats contained in the packet (e.g., MIME format or SQL format) and examines whether its payload is permitted. Thus, an ALG may be able to detect a computer virus contained in the payload. Because an ALG inspects packet payloads, it may be able to detect malicious code and quarantine suspicious packets, in addition to blocking packets with suspicious IP addresses and TCP ports. On the other hand, an ALG also incurs substantial computation and space overheads.","title":"Application Gateways(ALG)"},{"location":"level101/security/network_security/#trusted-systems-bastion-hosts","text":"A Trusted Operating System (TOS) is an operating system that meets a particular set of security requirements. Whether an operating system can be trusted or not depends on several elements. For example, for an operating system on a particular computer to be certified trusted, one needs to validate that, among other things, the following four requirements are satisfied: Its system design contains no defects; Its system software contains no loopholes; Its system is configured properly; and Its system management is appropriate. Bastion Hosts Bastion hosts are computers with strong defence mechanisms. They often serve as host computers for implementing application gateways, circuit gateways, and other types of firewalls. A bastion host is operated on a trusted operating system that must not contain unnecessary functionalities or programs. This measure helps to reduce error probabilities and makes it easier to conduct security checks. Only those network application programs that are necessary, for example, SSH, DNS, SMTP, and authentication programs, are installed on a bastion host. Bastion hosts are also primarily used as controlled ingress points so that the security monitoring can focus more narrowly on actions happening at a single point closely.","title":"Trusted Systems & Bastion Hosts"},{"location":"level101/security/network_security/#common-techniques-scannings-packet-capturing","text":"","title":"Common Techniques & Scannings, Packet Capturing"},{"location":"level101/security/network_security/#scanning-ports-with-nmap","text":"Nmap (\"Network Mapper\") is a free and open-source (license) utility for network discovery and security auditing. Many systems and network administrators also find it useful for tasks such as network inventory, managing service upgrade schedules, and monitoring host or service uptime. The best thing about Nmap is it\u2019s free and open-source and is very flexible and versatile Nmap is often used to determine alive hosts in a network, open ports on those hosts, services running on those open ports, and version identification of that service on that port. More at http://scanme.nmap.org/ nmap [scan type] [options] [target specification] Nmap uses 6 different port states: Open \u2014 An open port is one that is actively accepting TCP, UDP or SCTP connections. Open ports are what interests us the most because they are the ones that are vulnerable to attacks. Open ports also show the available services on a network. Closed \u2014 A port that receives and responds to Nmap probe packets but there is no application listening on that port. Useful for identifying that the host exists and for OS detection. Filtered \u2014 Nmap can\u2019t determine whether the port is open because packet filtering prevents its probes from reaching the port. Filtering could come from firewalls or router rules. Often little information is given from filtered ports during scans as the filters can drop the probes without responding or respond with useless error messages e.g. destination unreachable. Unfiltered \u2014 Port is accessible but Nmap doesn\u2019t know if it is open or closed. Only used in ACK scan which is used to map firewall rulesets. Other scan types can be used to identify whether the port is open. Open/filtered \u2014 Nmap is unable to determine between open and filtered. This happens when an open port gives no response. No response could mean that the probe was dropped by a packet filter or any response is blocked. Closed/filtered \u2014 Nmap is unable to determine whether a port is closed or filtered. Only used in the IP ID idle scan.","title":"Scanning Ports with Nmap"},{"location":"level101/security/network_security/#types-of-nmap-scan","text":"TCP Connect TCP Connect scan completes the 3-way handshake. If a port is open, the operating system completes the TCP three-way handshake and the port scanner immediately closes the connection to avoid DOS. This is \u201cnoisy\u201d because the services can log the sender IP address and might trigger Intrusion Detection Systems. UDP Scan This scan checks to see if any UDP ports are listening. Since UDP does not respond with a positive acknowledgement like TCP and only responds to an incoming UDP packet when the port is closed, SYN Scan SYN scan is another form of TCP scanning. This scan type is also known as \u201chalf-open scanning\u201d because it never actually opens a full TCP connection. The port scanner generates a SYN packet. If the target port is open, it will respond with an SYN-ACK packet. The scanner host responds with an RST packet, closing the connection before the handshake is completed. If the port is closed but unfiltered, the target will instantly respond with an RST packet. SYN scan has the advantage that the individual services never actually receive a connection. FIN Scan This is a stealthy scan, like the SYN scan, but sends a TCP FIN packet instead. ACK Scan Ack scanning determines whether the port is filtered or not. Null Scan Another very stealthy scan that sets all the TCP header flags to off or null. This is not normally a valid packet and some hosts will not know what to do with this. XMAS Scan Similar to the NULL scan except for all the flags in the TCP header is set to on RPC Scan This special type of scan looks for machine answering to RPC (Remote Procedure Call) services IDLE Scan It is a super stealthy method whereby the scan packets are bounced off an external host. You don\u2019t need to have control over the other host but it does have to set up and meet certain requirements. You must input the IP address of our \u201czombie\u201d host and what port number to use. It is one of the more controversial options in Nmap since it only has a use for malicious attacks. Scan Techniques A couple of scan techniques which can be used to gain more information about a system and its ports. You can read more at https://medium.com/infosec-adventures/nmap-cheatsheet-a423fcdda0ca","title":"Types of Nmap Scan:"},{"location":"level101/security/network_security/#openvas","text":"OpenVAS is a full-featured vulnerability scanner. OpenVAS is a framework of services and tools that provides a comprehensive and powerful vulnerability scanning and management package OpenVAS, which is an open-source program, began as a fork of the once-more-popular scanning program, Nessus. OpenVAS is made up of three main parts. These are: a regularly updated feed of Network Vulnerability Tests (NVTs); a scanner, which runs the NVTs; and an SQLite 3 database for storing both your test configurations and the NVTs\u2019 results and configurations. https://www.greenbone.net/en/install_use_gce/","title":"OpenVAS"},{"location":"level101/security/network_security/#wireshark","text":"Wireshark is a protocol analyzer. This means Wireshark is designed to decode not only packet bits and bytes but also the relations between packets and protocols. Wireshark understands protocol sequences. A simple demo of Wireshark Capture only udp packets: Capture filter = \u201cudp\u201d Capture only tcp packets Capture filter = \u201ctcp\u201d TCP/IP 3 way Handshake Filter by IP address: displays all traffic from IP, be it source or destination ip.addr == 192.168.1.1 Filter by source address: display traffic only from IP source ip.src == 192.168.0.1 Filter by destination: display traffic only form IP destination ip.dst == 192.168.0.1 Filter by IP subnet: display traffic from subnet, be it source or destination ip.addr = 192.168.0.1/24 Filter by protocol: filter traffic by protocol name dns http ftp arp ssh telnet icmp Exclude IP address: remove traffic from and to IP address !ip.addr ==192.168.0.1 Display traffic between two specific subnet ip.addr == 192.168.0.1/24 and ip.addr == 192.168.1.1/24 Display traffic between two specific workstations ip.addr == 192.168.0.1 and ip.addr == 192.168.0.2 Filter by MAC eth.addr = 00:50:7f:c5:b6:78 Filter TCP port tcp.port == 80 Filter TCP port source tcp.srcport == 80 Filter TCP port destination tcp.dstport == 80 Find user agents http.user_agent contains Firefox !http.user_agent contains || !http.user_agent contains Chrome Filter broadcast traffic !(arp or icmp or dns) Filter IP address and port tcp.port == 80 && ip.addr == 192.168.0.1 Filter all http get requests http.request Filter all http get requests and responses http.request or http.response Filter three way handshake tcp.flags.syn==1 or (tcp.seq==1 and tcp.ack==1 and tcp.len==0 and tcp.analysis.initial_rtt) Find files by type frame contains \u201c(attachment|tar|exe|zip|pdf)\u201d Find traffic based on keyword tcp contains facebook frame contains facebook Detecting SYN Floods tcp.flags.syn == 1 and tcp.flags.ack == 0 Wireshark Promiscuous Mode - By default, Wireshark only captures packets going to and from the computer where it runs. By checking the box to run Wireshark in Promiscuous Mode in the Capture Settings, you can capture most of the traffic on the LAN.","title":"WireShark"},{"location":"level101/security/network_security/#dumpcap","text":"Dumpcap is a network traffic dump tool. It captures packet data from a live network and writes the packets to a file. Dumpcap\u2019s native capture file format is pcapng, which is also the format used by Wireshark. By default, Dumpcap uses the pcap library to capture traffic from the first available network interface and writes the received raw packet data, along with the packets\u2019 time stamps into a pcapng file. The capture filter syntax follows the rules of the pcap library. The Wireshark command-line utility called 'dumpcap.exe' can be used to capture LAN traffic over an extended period of time. Wireshark itself can also be used, but dumpcap does not significantly utilize the computer's memory while capturing for long periods.","title":"DumpCap"},{"location":"level101/security/network_security/#daemonlogger","text":"Daemonlogger is a packet logging application designed specifically for use in Network and Systems Management (NSM) environments. The biggest benefit Daemonlogger provides is that, like Dumpcap, it is simple to use for capturing packets. In order to begin capturing, you need only to invoke the command and specify an interface. daemonlogger \u2013i eth1 This option, by default, will begin capturing packets and logging them to the current working directory. Packets will be collected until the capture file size reaches 2 GB, and then a new file will be created. This will continue indefinitely until the process is halted.","title":"DaemonLogger"},{"location":"level101/security/network_security/#netsniff-ng","text":"Netsniff-NG is a high-performance packet capture utility While the utilities we\u2019ve discussed to this point rely on Libpcap for capture, Netsniff-NG utilizes zero-copy mechanisms to capture packets. This is done with the intent to support full packet capture over high throughput links. To begin capturing packets with Netsniff-NG, we have to specify an input and output. In most cases, the input will be a network interface, and the output will be a file or folder on disk. netsniff-ng \u2013i eth1 \u2013o data.pcap","title":"NetSniff-NG"},{"location":"level101/security/network_security/#netflow","text":"NetFlow is a feature that was introduced on Cisco routers around 1996 that provides the ability to collect IP network traffic as it enters or exits an interface. By analyzing the data provided by NetFlow, a network administrator can determine things such as the source and destination of traffic, class of service, and the causes of congestion. A typical flow monitoring setup (using NetFlow) consists of three main components:[1] Flow exporter: aggregates packets into flows and exports flow records towards one or more flow collectors. Flow collector: responsible for reception, storage and pre-processing of flow data received from a flow exporter. Analysis application: analyzes received flow data in the context of intrusion detection or traffic profiling, for example. Routers and switches that support NetFlow can collect IP traffic statistics on all interfaces where NetFlow is enabled, and later export those statistics as NetFlow records toward at least one NetFlow collector\u2014typically a server that does the actual traffic analysis.","title":"Netflow"},{"location":"level101/security/network_security/#ids","text":"A security solution that detects security-related events in your environment but does not block them. IDS sensors can be software and hardware-based used to collect and analyze the network traffic. These sensors are available in two varieties, network IDS and host IDS. A host IDS is a server-specific agent running on a server with a minimum of overhead to monitor the operating system. A network IDS can be embedded in a networking device, a standalone appliance, or a module monitoring the network traffic. Signature Based IDS The signature-based IDS monitors the network traffic or observes the system and sends an alarm if a known malicious event is happening. It does so by comparing the data flow against a database of known attack patterns These signatures explicitly define what traffic or activity should be considered as malicious. Signature-based detection has been the bread and butter of network-based defensive security for over a decade, partially because it is very similar to how malicious activity is detected at the host level with antivirus utilities The formula is fairly simple: an analyst observes a malicious activity, derives indicators from the activity and develops them into signatures, and then those signatures will alert whenever the activity occurs again. ex: SNORT & SURICATA Policy-Based IDS The policy-based IDSs (mainly host IDSs) trigger an alarm whenever a violation occurs against the configured policy. This configured policy is or should be a representation of the security policies. This type of IDS is flexible and can be customized to a company's network requirements because it knows exactly what is permitted and what is not. On the other hand, the signature-based systems rely on vendor specifics and default settings. Anomaly Based IDS The anomaly-based IDS looks for traffic that deviates from the normal, but the definition of what is a normal network traffic pattern is the tricky part Two types of anomaly-based IDS exist: statistical and nonstatistical anomaly detection Statistical anomaly detection learns the traffic patterns interactively over a period of time. In the nonstatistical approach, the IDS has a predefined configuration of the supposedly acceptable and valid traffic patterns. Host-Based IDS & Network-Based IDS A host IDS can be described as a distributed agent residing on each server of the network that needs protection. These distributed agents are tied very closely to the underlying operating system. Network IDSs, on the other hand, can be described as intelligent sniffing devices. Data (raw packets) is captured from the network by a network IDS, whereas host IDSs capture the data from the host on which they are installed. Honeypots The use of decoy machines to direct intruders' attention away from the machines under protection is a major technique to preclude intrusion attacks. Any device, system, directory, or file used as a decoy to lure attackers away from important assets and to collect intrusion or abusive behaviours is referred to as a honeypot. A honeypot may be implemented as a physical device or as an emulation system. The idea is to set up decoy machines in a LAN, or decoy directories/files in a file system and make them appear important, but with several exploitable loopholes, to lure attackers to attack these machines or directories/files, so that other machines, directories, and files can evade intruders' attentions. A decoy machine may be a host computer or a server computer. Likewise, we may also set up decoy routers or even decoy LANs.","title":"IDS"},{"location":"level101/security/network_security/#chinks-in-the-armour-tcpip-security-issues","text":"","title":"Chinks In The Armour (TCP/IP Security Issues)"},{"location":"level101/security/network_security/#ip-spoofing","text":"In this type of attack, the attacker replaces the IP address of the sender, or in some rare cases the destination, with a different address. IP spoofing is normally used to exploit a target host. In other cases, it is used to start a denial-of-service (DoS) attack. In a DoS attack, an attacker modifies the IP packet to mislead the target host into accepting the original packet as a packet sourced at a trusted host. The attacker must know the IP address of the trusted host to modify the packet headers (source IP address) so that it appears that the packets are coming from that host. IP Spoofing Detection Techniques Direct TTL Probes In this technique we send a packet to a host of suspect spoofed IP that triggers reply and compares TTL with suspect packet; if the TTL in the reply is not the same as the packet being checked; it is a spoofed packet. This Technique is successful when the attacker is in a different subnet from the victim. IP Identification Number. Send a probe to the host of suspect spoofed traffic that triggers a reply and compares IP ID with suspect traffic. If IP IDs are not in the near value of packet being checked, suspect traffic is spoofed TCP Flow Control Method Attackers sending spoofed TCP packets will not receive the target\u2019s SYN-ACK packets. Attackers cannot, therefore, be responsive to change in the congestion window size When the receiver still receives traffic even after a windows size is exhausted, most probably the packets are spoofed.","title":"IP Spoofing"},{"location":"level101/security/network_security/#covert-channel","text":"A covert or clandestine channel can be best described as a pipe or communication channel between two entities that can be exploited by a process or application transferring information in a manner that violates the system's security specifications. More specifically for TCP/IP, in some instances, covert channels are established, and data can be secretly passed between two end systems. Ex: ICMP resides at the Internet layer of the TCP/IP protocol suite and is implemented in all TCP/IP hosts. Based on the specifications of the ICMP Protocol, an ICMP Echo Request message should have an 8-byte header and a 56-byte payload. The ICMP Echo Request packet should not carry any data in the payload. However, these packets are often used to carry secret information. The ICMP packets are altered slightly to carry secret data in the payload. This makes the size of the packet larger, but no control exists in the protocol stack to defeat this behaviour. The alteration of ICMP packets allows intruders to program specialized client-server pairs. These small pieces of code export confidential information without alerting the network administrator. ICMP can be leveraged for more than data exfiltration. For eg. some C&C tools such as Loki used ICMP channel to establish encrypted interactive session back in 1996. Deep packet inspection has since come a long way. A lot of IDS/IPS detect ICMP tunnelling. Check for echo responses that do not contain the same payload as request Check for the volume of ICMP traffic especially for volumes beyond an acceptable threshold","title":"Covert Channel"},{"location":"level101/security/network_security/#ip-fragmentation-attack","text":"The TCP/IP protocol suite, or more specifically IP, allows the fragmentation of packets.(this is a feature & not a bug) IP fragmentation offset is used to keep track of the different parts of a datagram. The information or content in this field is used at the destination to reassemble the datagrams All such fragments have the same Identification field value, and the fragmentation offset indicates the position of the current fragment in the context of the original packet. Many access routers and firewalls do not perform packet reassembly. In normal operation, IP fragments do not overlap, but attackers can create artificially fragmented packets to mislead the routers or firewalls. Usually, these packets are small and almost impractical for end systems because of data and computational overhead. A good example of an IP fragmentation attack is the Ping of Death attack. The Ping of Death attack sends fragments that, when reassembled at the end station, create a larger packet than the maximum permissible length. TCP Flags Data exchange using TCP does not happen until a three-way handshake has been completed. This handshake uses different flags to influence the way TCP segments are processed. There are 6 bits in the TCP header that are often called flags. Namely: 6 different flags are part of the TCP header: Urgent pointer field (URG), Acknowledgment field (ACK), Push function (PSH), Reset the connection (RST), Synchronize sequence numbers (SYN), and the sender is finished with this connection (FIN). Abuse of the normal operation or settings of these flags can be used by attackers to launch DoS attacks. This causes network servers or web servers to crash or hang. | SYN | FIN | PSH | RST | Validity| |------|------|-------|------|---------| | 1 |1 |0 |0 |Illegal Combination | 1 |1 |1 |0 |Illegal Combination | 1 |1 |0 |1 |Illegal Combination | 1 |1 |1 |1 |Illegal Combination The attacker's ultimate goal is to write special programs or pieces of code that can construct these illegal combinations resulting in an efficient DoS attack. SYN FLOOD The timers (or lack of certain timers) in 3 way handshake are often used and exploited by attackers to disable services or even to enter systems. After step 2 of the three-way handshake, no limit is set on the time to wait after receiving a SYN. The attacker initiates many connection requests to the webserver of Company XYZ (almost certainly with a spoofed IP address). The SYN+ACK packets (Step 2) sent by the web server back to the originating source IP address are not replied to. This leaves a TCP session half-open on the webserver. Multiple packets cause multiple TCP sessions to stay open. Based on the hardware limitations of the server, a limited number of TCP sessions can stay open, and as a result, the webserver refuses further connection establishments attempts from any host as soon as a certain limit is reached. These half-open connections need to be completed or timed out before new connections can be established. FIN Attack In normal operation, the sender sets the TCP FIN flag indicating that no more data will be transmitted and the connection can be closed down. This is a four-way handshake mechanism, with both sender and receiver expected to send an acknowledgement on a received FIN packet. During an attack that is trying to kill connections, a spoofed FIN packet is constructed. This packet also has the correct sequence number, so the packets are seen as valid by the targeted host. These sequence numbers are easy to predict. This process is referred to as TCP sequence number prediction, whereby the attacker either sniffs the current Sequence and Acknowledgment (SEQ/ACK) numbers of the connection or can algorithmically predict these numbers.","title":"IP Fragmentation Attack"},{"location":"level101/security/network_security/#connection-hijacking","text":"An authorized user (Employee X) sends HTTP requests over a TCP session with the webserver. The web server accepts the packets from Employee X only when the packet has the correct SEQ/ACK numbers. As seen previously, these numbers are important for the webserver to distinguish between different sessions and to make sure it is still talking to Employee X. Imagine that the cracker starts sending packets to the web server spoofing the IP address of Employee X, using the correct SEQ/ACK combination. The web server accepts the packet and increments the ACK number. In the meantime, Employee X continues to send packets but with incorrect SEQ/ACK numbers. As a result of sending unsynchronized packets, all data from Employee X is discarded when received by the webserver. The attacker pretends to be Employee X using the correct numbers. This finally results in the cracker hijacking the connection, whereby Employee X is completely confused and the webserver replies assuming the cracker is sending correct synchronized data. STEPS: The attacker examines the traffic flows with a network monitor and notices traffic from Employee X to a web server. The web server returns or echoes data back to the origination station (Employee X). Employee X acknowledges the packet. The cracker launches a spoofed packet to the server. The web server responds to the cracker. The cracker starts verifying SEQ/ACK numbers to double-check success. At this time, the cracker takes over the session from Employee X, which results in a session hanging for Employee X. The cracker can start sending traffic to the webserver. The web server returns the requested data to confirm delivery with the correct ACK number. The cracker can continue to send data (keeping track of the correct SEQ/ACK numbers) until eventually setting the FIN flag to terminate the session.","title":"Connection Hijacking"},{"location":"level101/security/network_security/#buffer-overflow","text":"A buffer is a temporary data storage area used to store program code and data. When a program or process tries to store more data in a buffer than it was originally anticipated to hold, a buffer overflow occurs. Buffers are temporary storage locations in memory (memory or buffer sizes are often measured in bytes) that can store a fixed amount of data in bytes. When more data is retrieved than can be stored in a buffer location, the additional information must go into an adjacent buffer, resulting in overwriting the valid data held in them. Mechanism: Buffer overflow vulnerabilities exist in different types. But the overall goal for all buffer overflow attacks is to take over the control of a privileged program and, if possible, the host. The attacker has two tasks to achieve this goal. First, the dirty code needs to be available in the program's code address space. Second, the privileged program should jump to that particular part of the code, which ensures that the proper parameters are loaded into memory. The first task can be achieved in two ways: by injecting the code in the right address space or by using the existing code and modifying certain parameters slightly. The second task is a little more complex because the program's control flow needs to be modified to make the program jump to the dirty code. CounterMeasure: The most important approach is to have a concerted focus on writing correct code. A second method is to make the data buffers (memory locations) address space of the program code non-executable. This type of address space makes it impossible to execute code, which might be infiltrated in the program's buffers during an attack.","title":"Buffer Overflow"},{"location":"level101/security/network_security/#more-spoofing","text":"Address Resolution Protocol Spoofing The Address Resolution Protocol (ARP) provides a mechanism to resolve, or map, a known IP address to a MAC sublayer address. Using ARP spoofing, the cracker can exploit this hardware address authentication mechanism by spoofing the hardware address of Host B. Basically, the attacker can convince any host or network device on the local network that the cracker's workstation is the host to be trusted. This is a common method used in a switched environment. ARP spoofing can be prevented with the implementation of static ARP tables in all the hosts and routers of your network. Alternatively, you can implement an ARP server that responds to ARP requests on behalf of the target host. DNS Spoofing DNS spoofing is the method whereby the hacker convinces the target machine that the system it wants to connect to is the machine of the cracker. The cracker modifies some records so that name entries of hosts correspond to the attacker's IP address. There have been instances in which the complete DNS server was compromised by an attack. To counter DNS spoofing, the reverse lookup detects these attacks. The reverse lookup is a mechanism to verify the IP address against a name. The IP address and name files are usually kept on different servers to make compromise much more difficult","title":"More Spoofing"},{"location":"level101/security/threats_attacks_defences/","text":"Part III: Threats, Attacks & Defense DNS Protection Cache Poisoning Attack Since DNS responses are cached, a quick response can be provided for repeated translations. DNS negative queries are also cached, e.g., misspelt words, and all cached data periodically times out. Cache poisoning is an issue in what is known as pharming. This term is used to describe a hacker\u2019s attack in which a website\u2019s traffic is redirected to a bogus website by forging the DNS mapping. In this case, an attacker attempts to insert a fake address record for an Internet domain into the DNS. If the server accepts the fake record, the cache is poisoned and subsequent requests for the address of the domain are answered with the address of a server controlled by the attacker. As long as the fake entry is cached by the server, browsers or e-mail servers will automatically go to the address provided by the compromised DNS server. the typical time to live (TTL) for cached entries is a couple of hours, thereby permitting ample time for numerous users to be affected by the attack. DNSSEC (Security Extension) The long-term solution to these DNS problems is authentication. If a resolver cannot distinguish between valid and invalid data in a response, then add source authentication to verify that the data received in response is equal to the data entered by the zone administrator DNS Security Extensions (DNSSEC) protects against data spoofing and corruption and provides mechanisms to authenticate servers and requests, as well as mechanisms to establish authenticity and integrity. When authenticating DNS responses, each DNS zone signs its data using a private key. It is recommended that this signing be done offline and in advance. The query for a particular record returns the requested resource record set (RRset) and signature (RRSIG) of the requested resource record set. The resolver then authenticates the response using a public key, which is pre-configured or learned via a sequence of key records in the DNS hierarchy. The goals of DNSSEC are to provide authentication and integrity for DNS responses without confidentiality or DDoS protection. BGP BGP stands for border gateway protocol. It is a routing protocol that exchanges routing information among multiple Autonomous Systems (AS) An Autonomous System is a collection of routers or networks with the same network policy usually under single administrative control. BGP tells routers which hop to use in order to reach the destination network. BGP is used for both communicating information among routers in an AS (interior) and between multiple ASes (exterior). How BGP Works BGP is responsible for finding a path to a destination router & the path it chooses should be the shortest and most reliable one. This decision is done through a protocol known as Link state. With the link-state protocol, each router broadcasts to all other routers in the network the state of its links and IP subnets. Each router then receives information from the other routers and constructs a complete topology view of the entire network. The next-hop routing table is based on this topology view. The link-state protocol uses a famous algorithm in the field of computer science, Dijkstra\u2019s shortest path algorithm: We start from our router considering the path cost to all our direct neighbours. The shortest path is then taken We then re-look at all our neighbours that we can reach and update our link state table with the cost information. We then continue taking the shortest path until every router has been visited. BGP Vulnerabilities By corrupting the BGP routing table we are able to influence the direction traffic flows on the internet! This action is known as BGP hijacking. Injecting bogus route advertising information into the BGP-distributed routing database by malicious sources, accidentally or routers can disrupt Internet backbone operations. Blackholing traffic: Blackhole route is a network route, i.e., routing table entry, that goes nowhere and packets matching the route prefix are dropped or ignored. Blackhole routes can only be detected by monitoring the lost traffic. Blackhole routes are the best defence against many common viral attacks where the traffic is dropped from infected machines to/from command & control hosts. Infamous BGP Injection attack on Youtube Ex: In 2008, Pakistan decided to block YouTube by creating a BGP route that led into a black hole. Instead, this routing information got transmitted to a hong kong ISP and from there accidentally got propagated to the rest of the world meaning millions were routed through to this black hole and therefore unable to access YouTube. Potentially, the greatest risk to BGP occurs in a denial of service attack in which a router is flooded with more packets than it can handle. Network overload and router resource exhaustion happen when the network begins carrying an excessive number of BGP messages, overloading the router control processors, memory, routing table and reducing the bandwidth available for data traffic. Refer: https://medium.com/bugbountywriteup/bgp-the-weak-link-in-the-internet-what-is-bgp-and-how-do-hackers-exploit-it-d899a68ba5bb Router flapping is another type of attack. Route flapping refers to repetitive changes to the BGP routing table, often several times a minute. Withdrawing and re-advertising at a high-rate can cause a serious problem for routers since they propagate the announcements of routes. If these route flaps happen fast enough, e.g., 30 to 50 times per second, the router becomes overloaded, which eventually prevents convergence on valid routes. The potential impact for Internet users is a slowdown in message delivery, and in some cases, packets may not be delivered at all. BGP Security Border Gateway Protocol Security recommends the use of BGP peer authentication since it is one of the strongest mechanisms for preventing malicious activity. The authentication mechanisms are Internet Protocol Security (IPsec) or BGP MD5. Another method, known as prefix limits, can be used to avoid filling router tables. In this approach, routers should be configured to disable or terminate a BGP peering session, and issue warning messages to administrators when a neighbour sends in excess of a preset number of prefixes. IETF is currently working on improving this space Web-Based Attacks HTTP Response Splitting Attacks HTTP response splitting attack may happen where the server script embeds user data in HTTP response headers without appropriate sanitation. This typically happens when the script embeds user data in the redirection URL of a redirection response (HTTP status code 3xx), or when the script embeds user data in a cookie value or name when the response sets a cookie. HTTP response splitting attacks can be used to perform web cache poisoning and cross-site scripting attacks. HTTP response splitting is the attacker\u2019s ability to send a single HTTP request that forces the webserver to form an output stream, which is then interpreted by the target as two HTTP responses instead of one response. Cross-Site Request Forgery (CSRF or XSRF) A Cross-Site Request Forgery attack tricks the victim\u2019s browser into issuing a command to a vulnerable web application. Vulnerability is caused by browsers automatically including user authentication data, session ID, IP address, Windows domain credentials, etc. with each request. Attackers typically use CSRF to initiate transactions such as transfer funds, login/logout user, close account, access sensitive data, and change account details. The vulnerability is caused by web browsers that automatically include credentials with each request, even for requests caused by a form, script, or image on another site. CSRF can also be dynamically constructed as part of a payload for a cross-site scripting attack All sites relying on automatic credentials are vulnerable. Popular browsers cannot prevent cross-site request forgery. Logging out of high-value sites as soon as possible can mitigate CSRF risk. It is recommended that a high-value website must require a client to manually provide authentication data in the same HTTP request used to perform any operation with security implications. Limiting the lifetime of session cookies can also reduce the chance of being used by other malicious sites. OWASP recommends website developers include a required security token in HTTP requests associated with sensitive business functions in order to mitigate CSRF attacks Cross-Site Scripting (XSS) Attacks Cross-Site Scripting occurs when dynamically generated web pages display user input, such as login information, that is not properly validated, allowing an attacker to embed malicious scripts into the generated page and then execute the script on the machine of any user that views the site. If successful, Cross-Site Scripting vulnerabilities can be exploited to manipulate or steal cookies, create requests that can be mistaken for those of a valid user, compromise confidential information, or execute malicious code on end-user systems. Cross-Site Scripting (XSS or CSS) attacks involve the execution of malicious scripts on the victim\u2019s browser. The victim is simply a user\u2019s host and not the server. XSS results from a failure to validate user input by a web-based application. Document Object Model (DOM) XSS Attacks The Document Object Model (DOM) based XSS does not require the webserver to receive the XSS payload for a successful attack. The attacker abuses the runtime by embedding their data on the client-side. An attacker can force the client (browser) to render the page with parts of the DOM controlled by the attacker. When the page is rendered and the data is processed by the page, typically by a client-side HTML-embedded script such as JavaScript, the page\u2019s code may insecurely embed the data in the page itself, thus delivering the cross-site scripting payload. There are several DOM objects which can serve as an attack vehicle for delivering malicious script to victims browser. Clickjacking The technique works by hiding malicious link/scripts under the cover of the content of a legitimate site. Buttons on a website actually contain invisible links, placed there by the attacker. So, an individual who clicks on an object they can visually see is actually being duped into visiting a malicious page or executing a malicious script. When mouseover is used together with clickjacking, the outcome is devastating. Facebook users have been hit by a clickjacking attack, which tricks people into \u201cliking\u201d a particular Facebook page, thus enabling the attack to spread since Memorial Day 2010. There is not yet effective defence against clickjacking, and disabling JavaScript is the only viable method DataBase Attacks & Defenses SQL injection Attacks It exploits improper input validation in database queries. A successful exploit will allow attackers to access, modify, or delete information in the database. It permits attackers to steal sensitive information stored within the backend databases of affected websites, which may include such things as user credentials, email addresses, personal information, and credit card numbers SELECT USERNAME,PASSWORD from USERS where USERNAME='' AND PASSWORD=''; Here the username & password is the input provided by the user. Suppose an attacker gives the input as \" OR '1'='1'\" in both fields. Therefore the SQL query will look like: SELECT USERNAME,PASSWORD from USERS where USERNAME='' OR '1'='1' AND PASSOWRD='' OR '1'='1'; This query results in a true statement & the user gets logged in. This example depicts the bost basic type of SQL injection SQL Injection Attack Defenses SQL injection can be protected by filtering the query to eliminate malicious syntax, which involves the employment of some tools in order to (a) scan the source code. In addition, the input fields should be restricted to the absolute minimum, typically anywhere from 7-12 characters, and validate any data, e.g., if a user inputs an age make sure the input is an integer with a maximum of 3 digits. VPN A virtual private network (VPN) is a service that offers a secure, reliable connection over a shared public infrastructure such as the Internet. Cisco defines a VPN as an encrypted connection between private networks over a public network. To date, there are three types of VPNs: Remote access Site-to-site Firewall-based Security Breach In spite of the most aggressive steps to protect computers from attacks, attackers sometimes get through. Any event that results in a violation of any of the confidentiality, integrity, or availability (CIA) security tenets is a security breach. Denial of Service Attacks Denial of service (DoS) attacks result in downtime or inability of a user to access a system. DoS attacks impact the availability of tenet of information systems security. A DoS attack is a coordinated attempt to deny service by occupying a computer to perform large amounts of unnecessary tasks. This excessive activity makes the system unavailable to perform legitimate operations Two common types of DoS attacks are as follows: Logic attacks\u2014Logic attacks use software flaws to crash or seriously hinder the performance of remote servers. You can prevent many of these attacks by installing the latest patches to keep your software up to date. Flooding attacks\u2014Flooding attacks overwhelm the victim computer\u2019s CPU, memory, or network resources by sending large numbers of useless requests to the machine. Most DoS attacks target weaknesses in the overall system architecture rather than a software bug or security flaw One popular technique for launching a packet flood is a SYN flood. One of the best defences against DoS attacks is to use intrusion prevention system (IPS) software or devices to detect and stop the attack. Distributed Denial of Service Attacks DDoS attacks differ from regular DoS attacks in their scope. In a DDoS attack, attackers hijack hundreds or even thousands of Internet computers, planting automated attack agents on those systems. The attacker then instructs the agents to bombard the target site with forged messages. This overloads the site and blocks legitimate traffic. The key here is strength in numbers. The attacker does more damage by distributing the attack across multiple computers. Wiretapping Although the term wiretapping is generally associated with voice telephone communications, attackers can also use wiretapping to intercept data communications. Attackers can tap telephone lines and data communication lines. Wiretapping can be active, where the attacker makes modifications to the line. It can also be passive, where an unauthorized user simply listens to the transmission without changing the contents. Passive intrusion can include the copying of data for a subsequent active attack. Two methods of active wiretapping are as follows: Between-the-lines wiretapping\u2014This type of wiretapping does not alter the messages sent by the legitimate user but inserts additional messages into the communication line when the legitimate user pauses. Piggyback-entry wiretapping\u2014This type of wiretapping intercepts and modifies the original message by breaking the communications line and routing the message to another computer that acts as a host. Backdoors Software developers sometimes include hidden access methods, called backdoors, in their programs. Backdoors give developers or support personnel easy access to a system without having to struggle with security controls. The problem is that backdoors don\u2019t always stay hidden. When an attacker discovers a backdoor, he or she can use it to bypass existing security controls such as passwords, encryption, and so on. Where legitimate users log on through front doors using a user ID and password, attackers use backdoors to bypass these normal access controls. Malicious Attacks Birthday Attack Once an attacker compromises a hashed password file, a birthday attack is performed. A birthday attack is a type of cryptographic attack that is used to make a brute-force attack of one-way hashes easier. It is a mathematical exploit that is based on the birthday problem in probability theory. Further Reading: https://www.sciencedirect.com/topics/computer-science/birthday-attack https://www.internetsecurity.tips/birthday-attack/ Brute-Force Password Attacks In a brute-force password attack, the attacker tries different passwords on a system until one of them is successful. Usually, the attacker employs a software program to try all possible combinations of a likely password, user ID, or security code until it locates a match. This occurs rapidly and in sequence. This type of attack is called a brute-force password attack because the attacker simply hammers away at the code. There is no skill or stealth involved\u2014just brute force that eventually breaks the code. Further Reading: https://owasp.org/www-community/attacks/Brute_force_attack https://owasp.org/www-community/controls/Blocking_Brute_Force_Attacks Dictionary Password Attacks A dictionary password attack is a simple attack that relies on users making poor password choices. In a dictionary password attack, a simple password-cracker program takes all the words from a dictionary file and attempts to log on by entering each dictionary entry as a password. Further Reading: https://capec.mitre.org/data/definitions/16.html Replay Attacks Replay attacks involve capturing data packets from a network and retransmitting them to produce an unauthorized effect. The receipt of duplicate, authenticated IP packets may disrupt service or have some other undesired consequence. Systems can be broken through replay attacks when attackers reuse old messages or parts of old messages to deceive system users. This helps intruders to gain information that allows unauthorized access into a system. Further reading: https://study.com/academy/lesson/replay-attack-definition-examples-prevention.html Man-in-the-Middle Attacks A man-in-the-middle attack takes advantage of the multihop process used by many types of networks. In this type of attack, an attacker intercepts messages between two parties before transferring them on to their intended destination. Web spoofing is a type of man-in-the-middle attack in which the user believes a secure session exists with a particular web server. In reality, the secure connection exists only with the attacker, not the webserver. The attacker then establishes a secure connection with the webserver, acting as an invisible go-between. The attacker passes traffic between the user and the webserver. In this way, the attacker can trick the user into supplying passwords, credit card information, and other private data. Further Reading: https://owasp.org/www-community/attacks/Man-in-the-middle_attack Masquerading In a masquerade attack, one user or computer pretends to be another user or computer. Masquerade attacks usually include one of the other forms of active attacks, such as IP address spoofing or replaying. Attackers can capture authentication sequences and then replay them later to log on again to an application or operating system. For example, an attacker might monitor usernames and passwords sent to a weak web application. The attacker could then use the intercepted credentials to log on to the web application and impersonate the user. Further Reading: https://dl.acm.org/doi/book/10.5555/2521792 https://ieeexplore.ieee.org/document/1653228 Eavesdropping Eavesdropping, or sniffing, occurs when a host sets its network interface on promiscuous mode and copies packets that pass by for later analysis. Promiscuous mode enables a network device to intercept and read each network packet(of course given some conditions) given sec, even if the packet\u2019s address doesn\u2019t match the network device. It is possible to attach hardware and software to monitor and analyze all packets on that segment of the transmission media without alerting any other users. Candidates for eavesdropping include satellite, wireless, mobile, and other transmission methods. Social Engineering Attackers often use a deception technique called social engineering to gain access to resources in an IT infrastructure. In nearly all cases, social engineering involves tricking authorized users into carrying out actions for unauthorized users. The success of social engineering attacks depends on the basic tendency of people to want to be helpful. Phreaking Phone phreaking, or simply phreaking, is a slang term that describes the activity of a subculture of people who study, experiment with, or explore telephone systems, telephone company equipment, and systems connected to public telephone networks. Phreaking is the art of exploiting bugs and glitches that exist in the telephone system. Phishing Phishing is a type of fraud in which an attacker attempts to trick the victim into providing private information such as credit card numbers, passwords, dates of birth, bank account numbers, automated teller machine (ATM) PINs, and Social Security numbers. Pharming Pharming is another type of attack that seeks to obtain personal or private financial information through domain spoofing. A pharming attack doesn\u2019t use messages to trick victims into visiting spoofed websites that appear legitimate, however. Instead, pharming \u201cpoisons\u201d a domain name on the domain name server (DNS), a process known as DNS poisoning. The result is that when a user enters the poisoned server\u2019s web address into his or her address bar, that user navigates to the attacker\u2019s site. The user\u2019s browser still shows the correct website, which makes pharming difficult to detect\u2014and therefore more serious. Where phishing attempts to scam people one at a time with an email or instant message, pharming enables scammers to target large groups of people at one time through domain spoofing.","title":"Threat, Attacks & Defences"},{"location":"level101/security/threats_attacks_defences/#part-iii-threats-attacks-defense","text":"","title":"Part III: Threats, Attacks & Defense"},{"location":"level101/security/threats_attacks_defences/#dns-protection","text":"","title":"DNS Protection"},{"location":"level101/security/threats_attacks_defences/#cache-poisoning-attack","text":"Since DNS responses are cached, a quick response can be provided for repeated translations. DNS negative queries are also cached, e.g., misspelt words, and all cached data periodically times out. Cache poisoning is an issue in what is known as pharming. This term is used to describe a hacker\u2019s attack in which a website\u2019s traffic is redirected to a bogus website by forging the DNS mapping. In this case, an attacker attempts to insert a fake address record for an Internet domain into the DNS. If the server accepts the fake record, the cache is poisoned and subsequent requests for the address of the domain are answered with the address of a server controlled by the attacker. As long as the fake entry is cached by the server, browsers or e-mail servers will automatically go to the address provided by the compromised DNS server. the typical time to live (TTL) for cached entries is a couple of hours, thereby permitting ample time for numerous users to be affected by the attack.","title":"Cache Poisoning Attack"},{"location":"level101/security/threats_attacks_defences/#dnssec-security-extension","text":"The long-term solution to these DNS problems is authentication. If a resolver cannot distinguish between valid and invalid data in a response, then add source authentication to verify that the data received in response is equal to the data entered by the zone administrator DNS Security Extensions (DNSSEC) protects against data spoofing and corruption and provides mechanisms to authenticate servers and requests, as well as mechanisms to establish authenticity and integrity. When authenticating DNS responses, each DNS zone signs its data using a private key. It is recommended that this signing be done offline and in advance. The query for a particular record returns the requested resource record set (RRset) and signature (RRSIG) of the requested resource record set. The resolver then authenticates the response using a public key, which is pre-configured or learned via a sequence of key records in the DNS hierarchy. The goals of DNSSEC are to provide authentication and integrity for DNS responses without confidentiality or DDoS protection.","title":"DNSSEC (Security Extension)"},{"location":"level101/security/threats_attacks_defences/#bgp","text":"BGP stands for border gateway protocol. It is a routing protocol that exchanges routing information among multiple Autonomous Systems (AS) An Autonomous System is a collection of routers or networks with the same network policy usually under single administrative control. BGP tells routers which hop to use in order to reach the destination network. BGP is used for both communicating information among routers in an AS (interior) and between multiple ASes (exterior).","title":"BGP"},{"location":"level101/security/threats_attacks_defences/#how-bgp-works","text":"BGP is responsible for finding a path to a destination router & the path it chooses should be the shortest and most reliable one. This decision is done through a protocol known as Link state. With the link-state protocol, each router broadcasts to all other routers in the network the state of its links and IP subnets. Each router then receives information from the other routers and constructs a complete topology view of the entire network. The next-hop routing table is based on this topology view. The link-state protocol uses a famous algorithm in the field of computer science, Dijkstra\u2019s shortest path algorithm: We start from our router considering the path cost to all our direct neighbours. The shortest path is then taken We then re-look at all our neighbours that we can reach and update our link state table with the cost information. We then continue taking the shortest path until every router has been visited.","title":"How BGP Works"},{"location":"level101/security/threats_attacks_defences/#bgp-vulnerabilities","text":"By corrupting the BGP routing table we are able to influence the direction traffic flows on the internet! This action is known as BGP hijacking. Injecting bogus route advertising information into the BGP-distributed routing database by malicious sources, accidentally or routers can disrupt Internet backbone operations. Blackholing traffic: Blackhole route is a network route, i.e., routing table entry, that goes nowhere and packets matching the route prefix are dropped or ignored. Blackhole routes can only be detected by monitoring the lost traffic. Blackhole routes are the best defence against many common viral attacks where the traffic is dropped from infected machines to/from command & control hosts. Infamous BGP Injection attack on Youtube Ex: In 2008, Pakistan decided to block YouTube by creating a BGP route that led into a black hole. Instead, this routing information got transmitted to a hong kong ISP and from there accidentally got propagated to the rest of the world meaning millions were routed through to this black hole and therefore unable to access YouTube. Potentially, the greatest risk to BGP occurs in a denial of service attack in which a router is flooded with more packets than it can handle. Network overload and router resource exhaustion happen when the network begins carrying an excessive number of BGP messages, overloading the router control processors, memory, routing table and reducing the bandwidth available for data traffic. Refer: https://medium.com/bugbountywriteup/bgp-the-weak-link-in-the-internet-what-is-bgp-and-how-do-hackers-exploit-it-d899a68ba5bb Router flapping is another type of attack. Route flapping refers to repetitive changes to the BGP routing table, often several times a minute. Withdrawing and re-advertising at a high-rate can cause a serious problem for routers since they propagate the announcements of routes. If these route flaps happen fast enough, e.g., 30 to 50 times per second, the router becomes overloaded, which eventually prevents convergence on valid routes. The potential impact for Internet users is a slowdown in message delivery, and in some cases, packets may not be delivered at all. BGP Security Border Gateway Protocol Security recommends the use of BGP peer authentication since it is one of the strongest mechanisms for preventing malicious activity. The authentication mechanisms are Internet Protocol Security (IPsec) or BGP MD5. Another method, known as prefix limits, can be used to avoid filling router tables. In this approach, routers should be configured to disable or terminate a BGP peering session, and issue warning messages to administrators when a neighbour sends in excess of a preset number of prefixes. IETF is currently working on improving this space","title":"BGP Vulnerabilities"},{"location":"level101/security/threats_attacks_defences/#web-based-attacks","text":"","title":"Web-Based Attacks"},{"location":"level101/security/threats_attacks_defences/#http-response-splitting-attacks","text":"HTTP response splitting attack may happen where the server script embeds user data in HTTP response headers without appropriate sanitation. This typically happens when the script embeds user data in the redirection URL of a redirection response (HTTP status code 3xx), or when the script embeds user data in a cookie value or name when the response sets a cookie. HTTP response splitting attacks can be used to perform web cache poisoning and cross-site scripting attacks. HTTP response splitting is the attacker\u2019s ability to send a single HTTP request that forces the webserver to form an output stream, which is then interpreted by the target as two HTTP responses instead of one response.","title":"HTTP Response Splitting Attacks"},{"location":"level101/security/threats_attacks_defences/#cross-site-request-forgery-csrf-or-xsrf","text":"A Cross-Site Request Forgery attack tricks the victim\u2019s browser into issuing a command to a vulnerable web application. Vulnerability is caused by browsers automatically including user authentication data, session ID, IP address, Windows domain credentials, etc. with each request. Attackers typically use CSRF to initiate transactions such as transfer funds, login/logout user, close account, access sensitive data, and change account details. The vulnerability is caused by web browsers that automatically include credentials with each request, even for requests caused by a form, script, or image on another site. CSRF can also be dynamically constructed as part of a payload for a cross-site scripting attack All sites relying on automatic credentials are vulnerable. Popular browsers cannot prevent cross-site request forgery. Logging out of high-value sites as soon as possible can mitigate CSRF risk. It is recommended that a high-value website must require a client to manually provide authentication data in the same HTTP request used to perform any operation with security implications. Limiting the lifetime of session cookies can also reduce the chance of being used by other malicious sites. OWASP recommends website developers include a required security token in HTTP requests associated with sensitive business functions in order to mitigate CSRF attacks","title":"Cross-Site Request Forgery (CSRF or XSRF)"},{"location":"level101/security/threats_attacks_defences/#cross-site-scripting-xss-attacks","text":"Cross-Site Scripting occurs when dynamically generated web pages display user input, such as login information, that is not properly validated, allowing an attacker to embed malicious scripts into the generated page and then execute the script on the machine of any user that views the site. If successful, Cross-Site Scripting vulnerabilities can be exploited to manipulate or steal cookies, create requests that can be mistaken for those of a valid user, compromise confidential information, or execute malicious code on end-user systems. Cross-Site Scripting (XSS or CSS) attacks involve the execution of malicious scripts on the victim\u2019s browser. The victim is simply a user\u2019s host and not the server. XSS results from a failure to validate user input by a web-based application.","title":"Cross-Site Scripting (XSS) Attacks"},{"location":"level101/security/threats_attacks_defences/#document-object-model-dom-xss-attacks","text":"The Document Object Model (DOM) based XSS does not require the webserver to receive the XSS payload for a successful attack. The attacker abuses the runtime by embedding their data on the client-side. An attacker can force the client (browser) to render the page with parts of the DOM controlled by the attacker. When the page is rendered and the data is processed by the page, typically by a client-side HTML-embedded script such as JavaScript, the page\u2019s code may insecurely embed the data in the page itself, thus delivering the cross-site scripting payload. There are several DOM objects which can serve as an attack vehicle for delivering malicious script to victims browser.","title":"Document Object Model (DOM) XSS Attacks"},{"location":"level101/security/threats_attacks_defences/#clickjacking","text":"The technique works by hiding malicious link/scripts under the cover of the content of a legitimate site. Buttons on a website actually contain invisible links, placed there by the attacker. So, an individual who clicks on an object they can visually see is actually being duped into visiting a malicious page or executing a malicious script. When mouseover is used together with clickjacking, the outcome is devastating. Facebook users have been hit by a clickjacking attack, which tricks people into \u201cliking\u201d a particular Facebook page, thus enabling the attack to spread since Memorial Day 2010. There is not yet effective defence against clickjacking, and disabling JavaScript is the only viable method","title":"Clickjacking"},{"location":"level101/security/threats_attacks_defences/#database-attacks-defenses","text":"","title":"DataBase Attacks & Defenses"},{"location":"level101/security/threats_attacks_defences/#sql-injection-attacks","text":"It exploits improper input validation in database queries. A successful exploit will allow attackers to access, modify, or delete information in the database. It permits attackers to steal sensitive information stored within the backend databases of affected websites, which may include such things as user credentials, email addresses, personal information, and credit card numbers SELECT USERNAME,PASSWORD from USERS where USERNAME='' AND PASSWORD=''; Here the username & password is the input provided by the user. Suppose an attacker gives the input as \" OR '1'='1'\" in both fields. Therefore the SQL query will look like: SELECT USERNAME,PASSWORD from USERS where USERNAME='' OR '1'='1' AND PASSOWRD='' OR '1'='1'; This query results in a true statement & the user gets logged in. This example depicts the bost basic type of SQL injection","title":"SQL injection Attacks"},{"location":"level101/security/threats_attacks_defences/#sql-injection-attack-defenses","text":"SQL injection can be protected by filtering the query to eliminate malicious syntax, which involves the employment of some tools in order to (a) scan the source code. In addition, the input fields should be restricted to the absolute minimum, typically anywhere from 7-12 characters, and validate any data, e.g., if a user inputs an age make sure the input is an integer with a maximum of 3 digits.","title":"SQL Injection Attack Defenses"},{"location":"level101/security/threats_attacks_defences/#vpn","text":"A virtual private network (VPN) is a service that offers a secure, reliable connection over a shared public infrastructure such as the Internet. Cisco defines a VPN as an encrypted connection between private networks over a public network. To date, there are three types of VPNs: Remote access Site-to-site Firewall-based","title":"VPN"},{"location":"level101/security/threats_attacks_defences/#security-breach","text":"In spite of the most aggressive steps to protect computers from attacks, attackers sometimes get through. Any event that results in a violation of any of the confidentiality, integrity, or availability (CIA) security tenets is a security breach.","title":"Security Breach"},{"location":"level101/security/threats_attacks_defences/#denial-of-service-attacks","text":"Denial of service (DoS) attacks result in downtime or inability of a user to access a system. DoS attacks impact the availability of tenet of information systems security. A DoS attack is a coordinated attempt to deny service by occupying a computer to perform large amounts of unnecessary tasks. This excessive activity makes the system unavailable to perform legitimate operations Two common types of DoS attacks are as follows: Logic attacks\u2014Logic attacks use software flaws to crash or seriously hinder the performance of remote servers. You can prevent many of these attacks by installing the latest patches to keep your software up to date. Flooding attacks\u2014Flooding attacks overwhelm the victim computer\u2019s CPU, memory, or network resources by sending large numbers of useless requests to the machine. Most DoS attacks target weaknesses in the overall system architecture rather than a software bug or security flaw One popular technique for launching a packet flood is a SYN flood. One of the best defences against DoS attacks is to use intrusion prevention system (IPS) software or devices to detect and stop the attack.","title":"Denial of Service Attacks"},{"location":"level101/security/threats_attacks_defences/#distributed-denial-of-service-attacks","text":"DDoS attacks differ from regular DoS attacks in their scope. In a DDoS attack, attackers hijack hundreds or even thousands of Internet computers, planting automated attack agents on those systems. The attacker then instructs the agents to bombard the target site with forged messages. This overloads the site and blocks legitimate traffic. The key here is strength in numbers. The attacker does more damage by distributing the attack across multiple computers.","title":"Distributed Denial of Service Attacks"},{"location":"level101/security/threats_attacks_defences/#wiretapping","text":"Although the term wiretapping is generally associated with voice telephone communications, attackers can also use wiretapping to intercept data communications. Attackers can tap telephone lines and data communication lines. Wiretapping can be active, where the attacker makes modifications to the line. It can also be passive, where an unauthorized user simply listens to the transmission without changing the contents. Passive intrusion can include the copying of data for a subsequent active attack. Two methods of active wiretapping are as follows: Between-the-lines wiretapping\u2014This type of wiretapping does not alter the messages sent by the legitimate user but inserts additional messages into the communication line when the legitimate user pauses. Piggyback-entry wiretapping\u2014This type of wiretapping intercepts and modifies the original message by breaking the communications line and routing the message to another computer that acts as a host.","title":"Wiretapping"},{"location":"level101/security/threats_attacks_defences/#backdoors","text":"Software developers sometimes include hidden access methods, called backdoors, in their programs. Backdoors give developers or support personnel easy access to a system without having to struggle with security controls. The problem is that backdoors don\u2019t always stay hidden. When an attacker discovers a backdoor, he or she can use it to bypass existing security controls such as passwords, encryption, and so on. Where legitimate users log on through front doors using a user ID and password, attackers use backdoors to bypass these normal access controls.","title":"Backdoors"},{"location":"level101/security/threats_attacks_defences/#malicious-attacks","text":"","title":"Malicious Attacks"},{"location":"level101/security/threats_attacks_defences/#birthday-attack","text":"Once an attacker compromises a hashed password file, a birthday attack is performed. A birthday attack is a type of cryptographic attack that is used to make a brute-force attack of one-way hashes easier. It is a mathematical exploit that is based on the birthday problem in probability theory. Further Reading: https://www.sciencedirect.com/topics/computer-science/birthday-attack https://www.internetsecurity.tips/birthday-attack/","title":"Birthday Attack"},{"location":"level101/security/threats_attacks_defences/#brute-force-password-attacks","text":"In a brute-force password attack, the attacker tries different passwords on a system until one of them is successful. Usually, the attacker employs a software program to try all possible combinations of a likely password, user ID, or security code until it locates a match. This occurs rapidly and in sequence. This type of attack is called a brute-force password attack because the attacker simply hammers away at the code. There is no skill or stealth involved\u2014just brute force that eventually breaks the code. Further Reading: https://owasp.org/www-community/attacks/Brute_force_attack https://owasp.org/www-community/controls/Blocking_Brute_Force_Attacks","title":"Brute-Force Password Attacks"},{"location":"level101/security/threats_attacks_defences/#dictionary-password-attacks","text":"A dictionary password attack is a simple attack that relies on users making poor password choices. In a dictionary password attack, a simple password-cracker program takes all the words from a dictionary file and attempts to log on by entering each dictionary entry as a password. Further Reading: https://capec.mitre.org/data/definitions/16.html","title":"Dictionary Password Attacks"},{"location":"level101/security/threats_attacks_defences/#replay-attacks","text":"Replay attacks involve capturing data packets from a network and retransmitting them to produce an unauthorized effect. The receipt of duplicate, authenticated IP packets may disrupt service or have some other undesired consequence. Systems can be broken through replay attacks when attackers reuse old messages or parts of old messages to deceive system users. This helps intruders to gain information that allows unauthorized access into a system. Further reading: https://study.com/academy/lesson/replay-attack-definition-examples-prevention.html","title":"Replay Attacks"},{"location":"level101/security/threats_attacks_defences/#man-in-the-middle-attacks","text":"A man-in-the-middle attack takes advantage of the multihop process used by many types of networks. In this type of attack, an attacker intercepts messages between two parties before transferring them on to their intended destination. Web spoofing is a type of man-in-the-middle attack in which the user believes a secure session exists with a particular web server. In reality, the secure connection exists only with the attacker, not the webserver. The attacker then establishes a secure connection with the webserver, acting as an invisible go-between. The attacker passes traffic between the user and the webserver. In this way, the attacker can trick the user into supplying passwords, credit card information, and other private data. Further Reading: https://owasp.org/www-community/attacks/Man-in-the-middle_attack","title":"Man-in-the-Middle Attacks"},{"location":"level101/security/threats_attacks_defences/#masquerading","text":"In a masquerade attack, one user or computer pretends to be another user or computer. Masquerade attacks usually include one of the other forms of active attacks, such as IP address spoofing or replaying. Attackers can capture authentication sequences and then replay them later to log on again to an application or operating system. For example, an attacker might monitor usernames and passwords sent to a weak web application. The attacker could then use the intercepted credentials to log on to the web application and impersonate the user. Further Reading: https://dl.acm.org/doi/book/10.5555/2521792 https://ieeexplore.ieee.org/document/1653228","title":"Masquerading"},{"location":"level101/security/threats_attacks_defences/#eavesdropping","text":"Eavesdropping, or sniffing, occurs when a host sets its network interface on promiscuous mode and copies packets that pass by for later analysis. Promiscuous mode enables a network device to intercept and read each network packet(of course given some conditions) given sec, even if the packet\u2019s address doesn\u2019t match the network device. It is possible to attach hardware and software to monitor and analyze all packets on that segment of the transmission media without alerting any other users. Candidates for eavesdropping include satellite, wireless, mobile, and other transmission methods.","title":"Eavesdropping"},{"location":"level101/security/threats_attacks_defences/#social-engineering","text":"Attackers often use a deception technique called social engineering to gain access to resources in an IT infrastructure. In nearly all cases, social engineering involves tricking authorized users into carrying out actions for unauthorized users. The success of social engineering attacks depends on the basic tendency of people to want to be helpful.","title":"Social Engineering"},{"location":"level101/security/threats_attacks_defences/#phreaking","text":"Phone phreaking, or simply phreaking, is a slang term that describes the activity of a subculture of people who study, experiment with, or explore telephone systems, telephone company equipment, and systems connected to public telephone networks. Phreaking is the art of exploiting bugs and glitches that exist in the telephone system.","title":"Phreaking"},{"location":"level101/security/threats_attacks_defences/#phishing","text":"Phishing is a type of fraud in which an attacker attempts to trick the victim into providing private information such as credit card numbers, passwords, dates of birth, bank account numbers, automated teller machine (ATM) PINs, and Social Security numbers.","title":"Phishing"},{"location":"level101/security/threats_attacks_defences/#pharming","text":"Pharming is another type of attack that seeks to obtain personal or private financial information through domain spoofing. A pharming attack doesn\u2019t use messages to trick victims into visiting spoofed websites that appear legitimate, however. Instead, pharming \u201cpoisons\u201d a domain name on the domain name server (DNS), a process known as DNS poisoning. The result is that when a user enters the poisoned server\u2019s web address into his or her address bar, that user navigates to the attacker\u2019s site. The user\u2019s browser still shows the correct website, which makes pharming difficult to detect\u2014and therefore more serious. Where phishing attempts to scam people one at a time with an email or instant message, pharming enables scammers to target large groups of people at one time through domain spoofing.","title":"Pharming"},{"location":"level101/security/writing_secure_code/","text":"PART IV: Writing Secure Code & More The first and most important step in reducing security and reliability issues is to educate developers. However, even the best-trained engineers make mistakes, security experts can write insecure code and SREs can miss reliability issues. It\u2019s difficult to keep the many considerations and tradeoffs involved in building secure and reliable systems in mind simultaneously, especially if you\u2019re also responsible for producing software. Use frameworks to enforce security and reliability while writing code A better approach is to handle security and reliability in common frameworks, languages, and libraries. Ideally, libraries only expose an interface that makes writing code with common classes of security vulnerabilities impossible. Multiple applications can use each library or framework. When domain experts fix an issue, they remove it from all the applications the framework supports, allowing this engineering approach to scale better. Common Security Vulnerabilities In large codebases, a handful of classes account for the majority of security vulnerabilities, despite ongoing efforts to educate developers and introduce code review. OWASP and SANS publish lists of common vulnerability classes Write Simple Code Try to keep your code clean and simple. Avoid Multi-Level Nesting Multilevel nesting is a common anti-pattern that can lead to simple mistakes. If the error is in the most common code path, it will likely be captured by the unit tests. However, unit tests don\u2019t always check error handling paths in multilevel nested code. The error might result in decreased reliability (for example, if the service crashes when it mishandles an error) or a security vulnerability (like a mishandled authorization check error). Eliminate YAGNI Smells Sometimes developers overengineer solutions by adding functionality that may be useful in the future, \u201cjust in case.\u201d This goes against the YAGNI (You Aren\u2019t Gonna Need It) principle, which recommends implementing only the code that you need. YAGNI code adds unnecessary complexity because it needs to be documented, tested, and maintained. To summarize, avoiding YAGNI code leads to improved reliability, and simpler code leads to fewer security bugs, fewer opportunities to make mistakes, and less developer time spent maintaining unused code. Repay Technical Debt It is a common practice for developers to mark places that require further attention with TODO or FIXME annotations. In the short term, this habit can accelerate the delivery velocity for the most critical functionality, and allow a team to meet early deadlines\u2014but it also incurs technical debt. Still, it\u2019s not necessarily a bad practice, as long as you have a clear process (and allocate time) for repaying such debt. Refactoring Refactoring is the most effective way to keep a codebase clean and simple. Even a healthy codebase occasionally needs to be Regardless of the reasons behind refactoring, you should always follow one golden rule: never mix refactoring and functional changes in a single commit to the code repository. Refactoring changes are typically significant and can be difficult to understand. If a commit also includes functional changes, there\u2019s a higher risk that an author or reviewer might overlook bugs. Unit Testing Unit testing can increase system security and reliability by pinpointing a wide range of bugs in individual software components before a release. This technique involves breaking software components into smaller, self-contained \u201cunits\u201d that have no external dependencies, and then testing each unit. Fuzz Testing Fuzz testing is a technique that complements the previously mentioned testing techniques. Fuzzing involves using a fuzzing engine to generate a large number of candidate inputs that are then passed through a fuzz driver to the fuzz target. The fuzzer then analyzes how the system handles the input. Complex inputs handled by all kinds of software are popular targets for fuzzing - for example, file parsers, compression algorithms, network protocol implementation and audio codec. Integration Testing Integration testing moves beyond individual units and abstractions, replacing fake or stubbed-out implementations of abstractions like databases or network services with real implementations. As a result, integration tests exercise more complete code paths. Because you must initialize and configure these other dependencies, integration testing may be slower and flakier than unit testing\u2014to execute the test, this approach incorporates real-world variables like network latency as services communicate end-to-end. As you move from testing individual low-level units of code to testing how they interact when composed together, the net result is a higher degree of confidence that the system is behaving as expected. Last But not the least Code Reviews Rely on Automation Don\u2019t check in Secrets Verifiable Builds","title":"Writing Secure code"},{"location":"level101/security/writing_secure_code/#part-iv-writing-secure-code-more","text":"The first and most important step in reducing security and reliability issues is to educate developers. However, even the best-trained engineers make mistakes, security experts can write insecure code and SREs can miss reliability issues. It\u2019s difficult to keep the many considerations and tradeoffs involved in building secure and reliable systems in mind simultaneously, especially if you\u2019re also responsible for producing software.","title":"PART IV: Writing Secure Code & More"},{"location":"level101/security/writing_secure_code/#use-frameworks-to-enforce-security-and-reliability-while-writing-code","text":"A better approach is to handle security and reliability in common frameworks, languages, and libraries. Ideally, libraries only expose an interface that makes writing code with common classes of security vulnerabilities impossible. Multiple applications can use each library or framework. When domain experts fix an issue, they remove it from all the applications the framework supports, allowing this engineering approach to scale better.","title":"Use frameworks to enforce security and reliability while writing code"},{"location":"level101/security/writing_secure_code/#common-security-vulnerabilities","text":"In large codebases, a handful of classes account for the majority of security vulnerabilities, despite ongoing efforts to educate developers and introduce code review. OWASP and SANS publish lists of common vulnerability classes","title":"Common Security Vulnerabilities"},{"location":"level101/security/writing_secure_code/#write-simple-code","text":"Try to keep your code clean and simple.","title":"Write Simple Code"},{"location":"level101/security/writing_secure_code/#avoid-multi-level-nesting","text":"Multilevel nesting is a common anti-pattern that can lead to simple mistakes. If the error is in the most common code path, it will likely be captured by the unit tests. However, unit tests don\u2019t always check error handling paths in multilevel nested code. The error might result in decreased reliability (for example, if the service crashes when it mishandles an error) or a security vulnerability (like a mishandled authorization check error).","title":"Avoid Multi-Level Nesting"},{"location":"level101/security/writing_secure_code/#eliminate-yagni-smells","text":"Sometimes developers overengineer solutions by adding functionality that may be useful in the future, \u201cjust in case.\u201d This goes against the YAGNI (You Aren\u2019t Gonna Need It) principle, which recommends implementing only the code that you need. YAGNI code adds unnecessary complexity because it needs to be documented, tested, and maintained. To summarize, avoiding YAGNI code leads to improved reliability, and simpler code leads to fewer security bugs, fewer opportunities to make mistakes, and less developer time spent maintaining unused code.","title":"Eliminate YAGNI Smells"},{"location":"level101/security/writing_secure_code/#repay-technical-debt","text":"It is a common practice for developers to mark places that require further attention with TODO or FIXME annotations. In the short term, this habit can accelerate the delivery velocity for the most critical functionality, and allow a team to meet early deadlines\u2014but it also incurs technical debt. Still, it\u2019s not necessarily a bad practice, as long as you have a clear process (and allocate time) for repaying such debt.","title":"Repay Technical Debt"},{"location":"level101/security/writing_secure_code/#refactoring","text":"Refactoring is the most effective way to keep a codebase clean and simple. Even a healthy codebase occasionally needs to be Regardless of the reasons behind refactoring, you should always follow one golden rule: never mix refactoring and functional changes in a single commit to the code repository. Refactoring changes are typically significant and can be difficult to understand. If a commit also includes functional changes, there\u2019s a higher risk that an author or reviewer might overlook bugs.","title":"Refactoring"},{"location":"level101/security/writing_secure_code/#unit-testing","text":"Unit testing can increase system security and reliability by pinpointing a wide range of bugs in individual software components before a release. This technique involves breaking software components into smaller, self-contained \u201cunits\u201d that have no external dependencies, and then testing each unit.","title":"Unit Testing"},{"location":"level101/security/writing_secure_code/#fuzz-testing","text":"Fuzz testing is a technique that complements the previously mentioned testing techniques. Fuzzing involves using a fuzzing engine to generate a large number of candidate inputs that are then passed through a fuzz driver to the fuzz target. The fuzzer then analyzes how the system handles the input. Complex inputs handled by all kinds of software are popular targets for fuzzing - for example, file parsers, compression algorithms, network protocol implementation and audio codec.","title":"Fuzz Testing"},{"location":"level101/security/writing_secure_code/#integration-testing","text":"Integration testing moves beyond individual units and abstractions, replacing fake or stubbed-out implementations of abstractions like databases or network services with real implementations. As a result, integration tests exercise more complete code paths. Because you must initialize and configure these other dependencies, integration testing may be slower and flakier than unit testing\u2014to execute the test, this approach incorporates real-world variables like network latency as services communicate end-to-end. As you move from testing individual low-level units of code to testing how they interact when composed together, the net result is a higher degree of confidence that the system is behaving as expected.","title":"Integration Testing"},{"location":"level101/security/writing_secure_code/#last-but-not-the-least","text":"Code Reviews Rely on Automation Don\u2019t check in Secrets Verifiable Builds","title":"Last But not the least"},{"location":"level101/systems_design/availability/","text":"HA - Availability - Common \u201cNines\u201d Availability is generally expressed as \u201cNines\u201d, common \u2018Nines\u2019 are listed below. Availability % Downtime per year Downtime per month Downtime per week Downtime per day 99%(Two Nines) 3.65 days 7.31 hours 1.68 hours 14.40 minutes 99.5%(Two and a half Nines) 1.83 days 3.65 hours 50.40 minutes 7.20 minutes 99.9%(Three Nines) 8.77 hours 43.83 minutes 10.08 minutes 1.44 minutes 99.95%(Three and a half Nines) 4.38 hours 21.92 minutes 5.04 minutes 43.20 seconds 99.99%(Four Nines) 52.60 minutes 4.38 minutes 1.01 minutes 8.64 seconds 99.995%(Four and a half Nines) 26.30 minutes 2.19 minutes 30.24 seconds 4.32 seconds 99.999%(Five Nines) 5.26 minutes 26.30 seconds 6.05 seconds 864.0 ms Refer https://en.wikipedia.org/wiki/High_availability#Percentage_calculation HA - Availability Serial Components A System with components is operating in the series If the failure of a part leads to the combination becoming inoperable. For example, if LB in our architecture fails, all access to app tiers will fail. LB and app tiers are connected serially. The combined availability of the system is the product of individual components availability A = Ax x Ay x \u2026.. Refer http://www.eventhelix.com/RealtimeMantra/FaultHandling/system_reliability_availability.htm HA - Availability Parallel Components A System with components is operating in parallel If the failure of a part leads to the other part taking over the operations of the failed part. If we have more than one LB and if the rest of the LBs can take over the traffic during one LB failure then LBs are operating in parallel The combined availability of the system is A = 1 - ( (1-Ax) x (1-Ax) x \u2026.. ) Refer http://www.eventhelix.com/RealtimeMantra/FaultHandling/system_reliability_availability.htm HA - Core Principles Elimination of single points of failure (SPOF) This means adding redundancy to the system so that the failure of a component does not mean failure of the entire system. Reliable crossover In redundant systems, the crossover point itself tends to become a single point of failure. Reliable systems must provide for reliable crossover. Detection of failures as they occur If the two principles above are observed, then a user may never see a failure Refer https://en.wikipedia.org/wiki/High_availability#Principles HA - SPOF WHAT: Never implement and always eliminate single points of failure. WHEN TO USE: During architecture reviews and new designs. HOW TO USE: Identify single instances on architectural diagrams. Strive for active/active configurations. At the very least we should have a standby to take control when active instances fail. WHY: Maximize availability through multiple instances. KEY TAKEAWAYS: Strive for active/active rather than active/passive solutions. Use load balancers to balance traffic across instances of a service. Use control services with active/passive instances for patterns that require singletons. HA - Reliable Crossover WHAT: Ensure when system components failover they do so reliably. WHEN TO USE: During architecture reviews, failure modeling, and designs. HOW TO USE: Identify how available a system is during the crossover and ensure it is within acceptable limits. WHY: Maximize availability and ensure data handling semantics are preserved. KEY TAKEAWAYS: Strive for active/active rather than active/passive solutions, they have a lesser risk of cross over being unreliable. Use LB and the right load balancing methods to ensure reliable failover. Model and build your data systems to ensure data is correctly handled when crossover happens. Generally, DB systems follow active/passive semantics for writes. Masters accept writes and when the master goes down, the follower is promoted to master(active from being passive) to accept writes. We have to be careful here that the cutover never introduces more than one master. This problem is called a split brain. Applications in SRE role SRE works on deciding an acceptable SLA and make sure the system is available to achieve the SLA SRE is involved in architecture design right from building the data center to make sure the site is not affected by a network switch, hardware, power, or software failures SRE also run mock drills of failures to see how the system behaves in uncharted territory and comes up with a plan to improve availability if there are misses. https://engineering.linkedin.com/blog/2017/11/resilience-engineering-at-linkedin-with-project-waterbear Post our understanding about HA, our architecture diagram looks something like this below","title":"Availability"},{"location":"level101/systems_design/availability/#ha-availability-common-nines","text":"Availability is generally expressed as \u201cNines\u201d, common \u2018Nines\u2019 are listed below. Availability % Downtime per year Downtime per month Downtime per week Downtime per day 99%(Two Nines) 3.65 days 7.31 hours 1.68 hours 14.40 minutes 99.5%(Two and a half Nines) 1.83 days 3.65 hours 50.40 minutes 7.20 minutes 99.9%(Three Nines) 8.77 hours 43.83 minutes 10.08 minutes 1.44 minutes 99.95%(Three and a half Nines) 4.38 hours 21.92 minutes 5.04 minutes 43.20 seconds 99.99%(Four Nines) 52.60 minutes 4.38 minutes 1.01 minutes 8.64 seconds 99.995%(Four and a half Nines) 26.30 minutes 2.19 minutes 30.24 seconds 4.32 seconds 99.999%(Five Nines) 5.26 minutes 26.30 seconds 6.05 seconds 864.0 ms","title":"HA - Availability - Common \u201cNines\u201d"},{"location":"level101/systems_design/availability/#refer","text":"https://en.wikipedia.org/wiki/High_availability#Percentage_calculation","title":"Refer"},{"location":"level101/systems_design/availability/#ha-availability-serial-components","text":"A System with components is operating in the series If the failure of a part leads to the combination becoming inoperable. For example, if LB in our architecture fails, all access to app tiers will fail. LB and app tiers are connected serially. The combined availability of the system is the product of individual components availability A = Ax x Ay x \u2026..","title":"HA - Availability Serial Components"},{"location":"level101/systems_design/availability/#refer_1","text":"http://www.eventhelix.com/RealtimeMantra/FaultHandling/system_reliability_availability.htm","title":"Refer"},{"location":"level101/systems_design/availability/#ha-availability-parallel-components","text":"A System with components is operating in parallel If the failure of a part leads to the other part taking over the operations of the failed part. If we have more than one LB and if the rest of the LBs can take over the traffic during one LB failure then LBs are operating in parallel The combined availability of the system is A = 1 - ( (1-Ax) x (1-Ax) x \u2026.. )","title":"HA - Availability Parallel Components"},{"location":"level101/systems_design/availability/#refer_2","text":"http://www.eventhelix.com/RealtimeMantra/FaultHandling/system_reliability_availability.htm","title":"Refer"},{"location":"level101/systems_design/availability/#ha-core-principles","text":"Elimination of single points of failure (SPOF) This means adding redundancy to the system so that the failure of a component does not mean failure of the entire system. Reliable crossover In redundant systems, the crossover point itself tends to become a single point of failure. Reliable systems must provide for reliable crossover. Detection of failures as they occur If the two principles above are observed, then a user may never see a failure","title":"HA - Core Principles"},{"location":"level101/systems_design/availability/#refer_3","text":"https://en.wikipedia.org/wiki/High_availability#Principles","title":"Refer"},{"location":"level101/systems_design/availability/#ha-spof","text":"WHAT: Never implement and always eliminate single points of failure. WHEN TO USE: During architecture reviews and new designs. HOW TO USE: Identify single instances on architectural diagrams. Strive for active/active configurations. At the very least we should have a standby to take control when active instances fail. WHY: Maximize availability through multiple instances. KEY TAKEAWAYS: Strive for active/active rather than active/passive solutions. Use load balancers to balance traffic across instances of a service. Use control services with active/passive instances for patterns that require singletons.","title":"HA - SPOF"},{"location":"level101/systems_design/availability/#ha-reliable-crossover","text":"WHAT: Ensure when system components failover they do so reliably. WHEN TO USE: During architecture reviews, failure modeling, and designs. HOW TO USE: Identify how available a system is during the crossover and ensure it is within acceptable limits. WHY: Maximize availability and ensure data handling semantics are preserved. KEY TAKEAWAYS: Strive for active/active rather than active/passive solutions, they have a lesser risk of cross over being unreliable. Use LB and the right load balancing methods to ensure reliable failover. Model and build your data systems to ensure data is correctly handled when crossover happens. Generally, DB systems follow active/passive semantics for writes. Masters accept writes and when the master goes down, the follower is promoted to master(active from being passive) to accept writes. We have to be careful here that the cutover never introduces more than one master. This problem is called a split brain.","title":"HA - Reliable Crossover"},{"location":"level101/systems_design/availability/#applications-in-sre-role","text":"SRE works on deciding an acceptable SLA and make sure the system is available to achieve the SLA SRE is involved in architecture design right from building the data center to make sure the site is not affected by a network switch, hardware, power, or software failures SRE also run mock drills of failures to see how the system behaves in uncharted territory and comes up with a plan to improve availability if there are misses. https://engineering.linkedin.com/blog/2017/11/resilience-engineering-at-linkedin-with-project-waterbear Post our understanding about HA, our architecture diagram looks something like this below","title":"Applications in SRE role"},{"location":"level101/systems_design/conclusion/","text":"Conclusion Armed with these principles, we hope the course will give a fresh perspective to design software systems. It might be over-engineering to get all this on day zero. But some are really important from day 0 like eliminating single points of failure, making scalable services by just increasing replicas. As a bottleneck is reached, we can split code by services, shard data to scale. As the organization matures, bringing in chaos engineering to measure how systems react to failure will help in designing robust software systems.","title":"Conclusion"},{"location":"level101/systems_design/conclusion/#conclusion","text":"Armed with these principles, we hope the course will give a fresh perspective to design software systems. It might be over-engineering to get all this on day zero. But some are really important from day 0 like eliminating single points of failure, making scalable services by just increasing replicas. As a bottleneck is reached, we can split code by services, shard data to scale. As the organization matures, bringing in chaos engineering to measure how systems react to failure will help in designing robust software systems.","title":"Conclusion"},{"location":"level101/systems_design/fault-tolerance/","text":"Fault Tolerance Failures are not avoidable in any system and will happen all the time, hence we need to build systems that can tolerate failures or recover from them. In systems, failure is the norm rather than the exception. \"Anything that can go wrong will go wrong\u201d -- Murphy\u2019s Law \u201cComplex systems contain changing mixtures of failures latent within them\u201d -- How Complex Systems Fail. Fault Tolerance - Failure Metrics Common failure metrics that get measured and tracked for any system. Mean time to repair (MTTR): The average time to repair and restore a failed system. Mean time between failures (MTBF): The average operational time between one device failure or system breakdown and the next. Mean time to failure (MTTF): The average time a device or system is expected to function before it fails. Mean time to detect (MTTD): The average time between the onset of a problem and when the organization detects it. Mean time to investigate (MTTI): The average time between the detection of an incident and when the organization begins to investigate its cause and solution. Mean time to restore service (MTRS): The average elapsed time from the detection of an incident until the affected system or component is again available to users. Mean time between system incidents (MTBSI): The average elapsed time between the detection of two consecutive incidents. MTBSI can be calculated by adding MTBF and MTRS (MTBSI = MTBF + MTRS). Failure rate: Another reliability metric, which measures the frequency with which a component or system fails. It is expressed as a number of failures over a unit of time. Refer https://www.splunk.com/en_us/data-insider/what-is-mean-time-to-repair.html Fault Tolerance - Fault Isolation Terms Systems should have a short circuit. Say in our content sharing system, if \u201cNotifications\u201d is not working, the site should gracefully handle that failure by removing the functionality instead of taking the whole site down. Swimlane is one of the commonly used fault isolation methodologies. Swimlane adds a barrier to the service from other services so that failure on either of them won\u2019t affect the other. Say we roll out a new feature \u2018Advertisement\u2019 in our content sharing app. We can have two architectures If Ads are generated on the fly synchronously during each Newsfeed request, the faults in the Ads feature get propagated to the Newsfeed feature. Instead if we swimlane the \u201cGeneration of Ads\u201d service and use a shared storage to populate Newsfeed App, Ads failures won\u2019t cascade to Newsfeed, and worst case if Ads don\u2019t meet SLA , we can have Newsfeed without Ads. Let's take another example, we have come up with a new model for our Content sharing App. Here we roll out an enterprise content sharing App where enterprises pay for the service and the content should never be shared outside the enterprise. Swimlane Principles Principle 1: Nothing is shared (also known as \u201cshare as little as possible\u201d). The less that is shared within a swim lane, the more fault isolative the swim lane becomes. (as shown in Enterprise use-case) Principle 2: Nothing crosses a swim lane boundary. Synchronous (defined by expecting a request\u2014not the transfer protocol) communication never crosses a swim lane boundary; if it does, the boundary is drawn incorrectly. (as shown in Ads feature) Swimlane Approaches Approach 1: Swim lane the money-maker. Never allow your cash register to be compromised by other systems. (Tier 1 vs Tier 2 in enterprise use case) Approach 2: Swim lane the biggest sources of incidents. Identify the recurring causes of pain and isolate them. (if Ads feature is in code yellow, swim laning it is the best option) Approach 3: Swim lane natural barriers. Customer boundaries make good swim lanes. (Public vs Enterprise customers) Refer https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch21.html#ch21 Applications in SRE role Work with the DC tech or cloud team to distribute infrastructure such that its immune to switch or power failures by creating fault zones within a Data Center https://docs.microsoft.com/en-us/azure/virtual-machines/manage-availability#use-availability-zones-to-protect-from-datacenter-level-failures Work with the partners and design interaction between services such that one service breakdown is not amplified in a cascading fashion to all upstreams","title":"Fault Tolerance"},{"location":"level101/systems_design/fault-tolerance/#fault-tolerance","text":"Failures are not avoidable in any system and will happen all the time, hence we need to build systems that can tolerate failures or recover from them. In systems, failure is the norm rather than the exception. \"Anything that can go wrong will go wrong\u201d -- Murphy\u2019s Law \u201cComplex systems contain changing mixtures of failures latent within them\u201d -- How Complex Systems Fail.","title":"Fault Tolerance"},{"location":"level101/systems_design/fault-tolerance/#fault-tolerance-failure-metrics","text":"Common failure metrics that get measured and tracked for any system. Mean time to repair (MTTR): The average time to repair and restore a failed system. Mean time between failures (MTBF): The average operational time between one device failure or system breakdown and the next. Mean time to failure (MTTF): The average time a device or system is expected to function before it fails. Mean time to detect (MTTD): The average time between the onset of a problem and when the organization detects it. Mean time to investigate (MTTI): The average time between the detection of an incident and when the organization begins to investigate its cause and solution. Mean time to restore service (MTRS): The average elapsed time from the detection of an incident until the affected system or component is again available to users. Mean time between system incidents (MTBSI): The average elapsed time between the detection of two consecutive incidents. MTBSI can be calculated by adding MTBF and MTRS (MTBSI = MTBF + MTRS). Failure rate: Another reliability metric, which measures the frequency with which a component or system fails. It is expressed as a number of failures over a unit of time.","title":"Fault Tolerance - Failure Metrics"},{"location":"level101/systems_design/fault-tolerance/#refer","text":"https://www.splunk.com/en_us/data-insider/what-is-mean-time-to-repair.html","title":"Refer"},{"location":"level101/systems_design/fault-tolerance/#fault-tolerance-fault-isolation-terms","text":"Systems should have a short circuit. Say in our content sharing system, if \u201cNotifications\u201d is not working, the site should gracefully handle that failure by removing the functionality instead of taking the whole site down. Swimlane is one of the commonly used fault isolation methodologies. Swimlane adds a barrier to the service from other services so that failure on either of them won\u2019t affect the other. Say we roll out a new feature \u2018Advertisement\u2019 in our content sharing app. We can have two architectures If Ads are generated on the fly synchronously during each Newsfeed request, the faults in the Ads feature get propagated to the Newsfeed feature. Instead if we swimlane the \u201cGeneration of Ads\u201d service and use a shared storage to populate Newsfeed App, Ads failures won\u2019t cascade to Newsfeed, and worst case if Ads don\u2019t meet SLA , we can have Newsfeed without Ads. Let's take another example, we have come up with a new model for our Content sharing App. Here we roll out an enterprise content sharing App where enterprises pay for the service and the content should never be shared outside the enterprise.","title":"Fault Tolerance - Fault Isolation Terms"},{"location":"level101/systems_design/fault-tolerance/#swimlane-principles","text":"Principle 1: Nothing is shared (also known as \u201cshare as little as possible\u201d). The less that is shared within a swim lane, the more fault isolative the swim lane becomes. (as shown in Enterprise use-case) Principle 2: Nothing crosses a swim lane boundary. Synchronous (defined by expecting a request\u2014not the transfer protocol) communication never crosses a swim lane boundary; if it does, the boundary is drawn incorrectly. (as shown in Ads feature)","title":"Swimlane Principles"},{"location":"level101/systems_design/fault-tolerance/#swimlane-approaches","text":"Approach 1: Swim lane the money-maker. Never allow your cash register to be compromised by other systems. (Tier 1 vs Tier 2 in enterprise use case) Approach 2: Swim lane the biggest sources of incidents. Identify the recurring causes of pain and isolate them. (if Ads feature is in code yellow, swim laning it is the best option) Approach 3: Swim lane natural barriers. Customer boundaries make good swim lanes. (Public vs Enterprise customers)","title":"Swimlane Approaches"},{"location":"level101/systems_design/fault-tolerance/#refer_1","text":"https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch21.html#ch21","title":"Refer"},{"location":"level101/systems_design/fault-tolerance/#applications-in-sre-role","text":"Work with the DC tech or cloud team to distribute infrastructure such that its immune to switch or power failures by creating fault zones within a Data Center https://docs.microsoft.com/en-us/azure/virtual-machines/manage-availability#use-availability-zones-to-protect-from-datacenter-level-failures Work with the partners and design interaction between services such that one service breakdown is not amplified in a cascading fashion to all upstreams","title":"Applications in SRE role"},{"location":"level101/systems_design/intro/","text":"Systems Design Prerequisites Fundamentals of common software system components: Linux Basics Linux Networking Databases RDBMS NoSQL Concepts What to expect from this course Thinking about and designing for scalability, availability, and reliability of large scale software systems. What is not covered under this course Individual software components\u2019 scalability and reliability concerns like e.g. Databases, while the same scalability principles and thinking can be applied, these individual components have their own specific nuances when scaling them and thinking about their reliability. More light will be shed on concepts rather than on setting up and configuring components like Loadbalancers to achieve scalability, availability, and reliability of systems Course Contents Introduction Scalability High Availability Fault Tolerance Introduction So, how do you go about learning to design a system? \u201d Like most great questions, it showed a level of naivety that was breathtaking. The only short answer I could give was, essentially, that you learned how to design a system by designing systems and finding out what works and what doesn\u2019t work.\u201d Jim Waldo, Sun Microsystems, On System Design As software and hardware systems have multiple moving parts, we need to think about how those parts will grow, their failure modes, their inter-dependencies, how it will impact the users and the business. There is no one-shot method or way to learn or do system design, we only learn to design systems by designing and iterating on them. This course will be a starter to make one think about scalability, availability, and fault tolerance during systems design. Backstory Let\u2019s design a simple content sharing application where users can share photos, media in our application which can be liked by their friends. Let\u2019s start with a simple design of the application and evolve it as we learn system design concepts","title":"Introduction"},{"location":"level101/systems_design/intro/#systems-design","text":"","title":"Systems Design"},{"location":"level101/systems_design/intro/#prerequisites","text":"Fundamentals of common software system components: Linux Basics Linux Networking Databases RDBMS NoSQL Concepts","title":"Prerequisites"},{"location":"level101/systems_design/intro/#what-to-expect-from-this-course","text":"Thinking about and designing for scalability, availability, and reliability of large scale software systems.","title":"What to expect from this course"},{"location":"level101/systems_design/intro/#what-is-not-covered-under-this-course","text":"Individual software components\u2019 scalability and reliability concerns like e.g. Databases, while the same scalability principles and thinking can be applied, these individual components have their own specific nuances when scaling them and thinking about their reliability. More light will be shed on concepts rather than on setting up and configuring components like Loadbalancers to achieve scalability, availability, and reliability of systems","title":"What is not covered under this course"},{"location":"level101/systems_design/intro/#course-contents","text":"Introduction Scalability High Availability Fault Tolerance","title":"Course Contents"},{"location":"level101/systems_design/intro/#introduction","text":"So, how do you go about learning to design a system? \u201d Like most great questions, it showed a level of naivety that was breathtaking. The only short answer I could give was, essentially, that you learned how to design a system by designing systems and finding out what works and what doesn\u2019t work.\u201d Jim Waldo, Sun Microsystems, On System Design As software and hardware systems have multiple moving parts, we need to think about how those parts will grow, their failure modes, their inter-dependencies, how it will impact the users and the business. There is no one-shot method or way to learn or do system design, we only learn to design systems by designing and iterating on them. This course will be a starter to make one think about scalability, availability, and fault tolerance during systems design.","title":"Introduction"},{"location":"level101/systems_design/intro/#backstory","text":"Let\u2019s design a simple content sharing application where users can share photos, media in our application which can be liked by their friends. Let\u2019s start with a simple design of the application and evolve it as we learn system design concepts","title":"Backstory"},{"location":"level101/systems_design/scalability/","text":"Scalability What does scalability mean for a system/service? A system is composed of services/components, each service/component scalability needs to be tackled separately, and the scalability of the system as a whole. A service is said to be scalable if, as resources are added to the system, it results in increased performance in a manner proportional to resources added An always-on service is said to be scalable if adding resources to facilitate redundancy does not result in a loss of performance Refer https://www.allthingsdistributed.com/2006/03/a_word_on_scalability.html Scalability - AKF Scale Cube The Scale Cube is a model for segmenting services, defining microservices, and scaling products. It also creates a common language for teams to discuss scale related options in designing solutions. The following section talks about certain scaling patterns based on our inferences from the AKF cube Scalability - Horizontal scaling Horizontal scaling stands for cloning of an application or service such that work can easily be distributed across instances with absolutely no bias. Let's see how our monolithic application improves with this principle Here DB is scaled separately from the application. This is to let you know each component\u2019s scaling capabilities can be different. Usually, web applications can be scaled by adding resources unless there is state stored inside the application. But DBs can be scaled only for Reads by adding more followers but Writes have to go to only one leader to make sure data is consistent. There are some DBs that support multi-leader writes but we are keeping them out of scope at this point. Apps should be able to differentiate between Reads and Writes to choose appropriate DB servers. Load balancers can split traffic between identical servers transparently. WHAT: Duplication of services or databases to spread transaction load. WHEN TO USE: Databases with a very high read-to-write ratio (5:1 or greater\u2014the higher the better). Because only read replicas of DBs can be scaled, not the Leader. HOW TO USE: Simply clone services and implement a load balancer. For databases, ensure that the accessing code understands the difference between a read and a write. WHY: Allows for the fast scale of transactions at the cost of duplicated data and functionality. KEY TAKEAWAYS: This is fast to implement, is a low cost from a developer effort perspective, and can scale transaction volumes nicely. However, they tend to be high cost from the perspective of the operational cost of data. The cost here means if we have 3 followers and 1 Leader DB, the same database will be stored as 4 copies in the 4 servers. Hence added storage cost Refer https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html Scalability Pattern - Load Balancing Improves the distribution of workloads across multiple computing resources, such as computers, a computer cluster, network links, central processing units, or disk drives. A commonly used technique is load balancing traffic across identical server clusters. A similar philosophy is used to load balance traffic across network links by ECMP , disk drives by RAID ,etc Aims to optimize resource use, maximize throughput, minimize response time, and avoid overload of any single resource. Using multiple components with load balancing instead of a single component may increase reliability and availability through redundancy. In our updated architecture diagram we have 4 servers to handle app traffic instead of a single server The device or system that performs load balancing is called a load balancer, abbreviated as LB. Refer https://en.wikipedia.org/wiki/Load_balancing_(computing) https://blog.envoyproxy.io/introduction-to-modern-network-load-balancing-and-proxying-a57f6ff80236 https://learning.oreilly.com/library/view/load-balancing-in/9781492038009/ https://learning.oreilly.com/library/view/practical-load-balancing/9781430236801/ http://shop.oreilly.com/product/9780596000509.do Scalability Pattern - LB Tasks What does an LB do? Service discovery: What backends are available in the system? In our architecture, 4 servers are available to serve App traffic. LB acts as a single endpoint that clients can use transparently to reach one of the 4 servers. Health checking: What backends are currently healthy and available to accept requests? If one out of the 4 App servers turns bad, LB should automatically short circuit the path so that clients don\u2019t sense any application downtime Load balancing: What algorithm should be used to balance individual requests across the healthy backends? There are many algorithms to distribute traffic across one of the four servers. Based on observations/experience, SRE can pick the algorithm that suits their pattern Scalability Pattern - LB Methods Common Load Balancing Methods Least Connection Method directs traffic to the server with the fewest active connections. Most useful when there are a large number of persistent connections in the traffic unevenly distributed between the servers. Works if clients maintain long-lived connections Least Response Time Method directs traffic to the server with the fewest active connections and the lowest average response time. Here response time is used to provide feedback of the server\u2019s health Round Robin Method rotates servers by directing traffic to the first available server and then moves that server to the bottom of the queue. Most useful when servers are of equal specification and there are not many persistent connections. IP Hash the IP address of the client determines which server receives the request. This can sometimes cause skewness in distribution but is useful if apps store some state locally and need some stickiness More advanced client/server-side example techniques - https://docs.nginx.com/nginx/admin-guide/load-balancer/ - http://cbonte.github.io/haproxy-dconv/2.2/intro.html#3.3.5 - https://twitter.github.io/finagle/guide/Clients.html#load-balancing Scalability Pattern - Caching - Content Delivery Networks (CDN) CDNs are added closer to the client\u2019s location. If the app has static data like images, Javascript, CSS which don\u2019t change very often, they can be cached. Since our example is a content sharing site, static content can be cached in CDNs with a suitable expiry. WHAT: Use CDNs (content delivery networks) to offload traffic from your site. WHEN TO USE: When speed improvements and scale warrant the additional cost. HOW TO USE: Most CDNs leverage DNS to serve content on your site\u2019s behalf. Thus you may need to make minor DNS changes or additions and move content to be served from new subdomains. Eg media-exp1.licdn.com is a domain used by Linkedin to serve static content Here a CNAME points the domain to the DNS of the CDN provider dig media-exp1.licdn.com +short 2-01-2c3e-005c.cdx.cedexis.net. WHY: CDNs help offload traffic spikes and are often economical ways to scale parts of a site\u2019s traffic. They also often substantially improve page download times. KEY TAKEAWAYS: CDNs are a fast and simple way to offset the spikiness of traffic as well as traffic growth in general. Make sure you perform a cost-benefit analysis and monitor the CDN usage. If CDNs have a lot of cache misses, then we don\u2019t gain much from CDN and are still serving requests using our compute resources. Scalability - Microservices This pattern represents the separation of work by service or function within the application. Microservices are meant to address the issues associated with growth and complexity in the code base and data sets. The intent is to create fault isolation as well as to reduce response times. Microservices can scale transactions, data sizes, and codebase sizes. They are most effective in scaling the size and complexity of your codebase. They tend to cost a bit more than horizontal scaling because the engineering team needs to rewrite services or, at the very least, disaggregate them from the original monolithic application. WHAT: Sometimes referred to as scale through services or resources, this rule focuses on scaling by splitting data sets, transactions, and engineering teams along verb (services) or noun (resources) boundaries. WHEN TO USE: Very large data sets where relations between data are not necessary. Large, complex systems where scaling engineering resources requires specialization. HOW TO USE: Split up actions by using verbs, or resources by using nouns, or use a mix. Split both the services and the data along the lines defined by the verb/noun approach. WHY: Allows for efficient scaling of not only transactions but also very large data sets associated with those transactions. It also allows for the efficient scaling of teams. KEY TAKEAWAYS: Microservices allow for efficient scaling of transactions, large data sets, and can help with fault isolation. It helps reduce the communication overhead of teams. The codebase becomes less complex as disjoint features are decoupled and spun as new services thereby letting each service scale independently specific to its requirement. Refer https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html Scalability - Sharding This pattern represents the separation of work based on attributes that are looked up to or determined at the time of the transaction. Most often, these are implemented as splits by requestor, customer, or client. Very often, a lookup service or deterministic algorithm will need to be written for these types of splits. Sharding aids in scaling transaction growth, scaling instruction sets, and decreasing processing time (the last by limiting the data necessary to perform any transaction). This is more effective at scaling growth in customers or clients. It can aid with disaster recovery efforts, and limit the impact of incidents to only a specific segment of customers. Here the auth data is sharded based on user names so that DBs can respond faster as the amount of data DBs have to work on has drastically reduced during queries. There can be other ways to split Here the whole data center is split and replicated and clients are directed to a data center based on their geography. This helps in improving performance as clients are directed to the closest data center and performance increases as we add more data centers. There are some replication and consistency overhead with this approach one needs to be aware of. This also gives fault tolerance by rolling out test features to one site and rollback if there is an impact to that geography WHAT: This is very often a split by some unique aspect of the customer such as customer ID, name, geography, and so on. WHEN TO USE: Very large, similar data sets such as large and rapidly growing customer bases or when the response time for a geographically distributed customer base is important. HOW TO USE: Identify something you know about the customer, such as customer ID, last name, geography, or device, and split or partition both data and services based on that attribute. WHY: Rapid customer growth exceeds other forms of data growth, or you have the need to perform fault isolation between certain customer groups as you scale. KEY TAKEAWAYS: Shards are effective at helping you to scale customer bases but can also be applied to other very large data sets that can\u2019t be pulled apart using the microservices methodology. Refer https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html Applications in SRE role SREs in coordination with the network team work on how to map users' traffic to a particular site. https://engineering.linkedin.com/blog/2017/05/trafficshift--load-testing-at-scale SREs work closely with the Dev team to split monoliths to multiple microservices that are easy to run and manage SREs work on improving Load Balancers' reliability, service discovery, and performance SREs work closely to split Data into shards and manage data integrity and consistency. https://engineering.linkedin.com/espresso/introducing-espresso-linkedins-hot-new-distributed-document-store SREs work to set up, configure, and improve the CDN cache hit rate.","title":"Scalability"},{"location":"level101/systems_design/scalability/#scalability","text":"What does scalability mean for a system/service? A system is composed of services/components, each service/component scalability needs to be tackled separately, and the scalability of the system as a whole. A service is said to be scalable if, as resources are added to the system, it results in increased performance in a manner proportional to resources added An always-on service is said to be scalable if adding resources to facilitate redundancy does not result in a loss of performance","title":"Scalability"},{"location":"level101/systems_design/scalability/#refer","text":"https://www.allthingsdistributed.com/2006/03/a_word_on_scalability.html","title":"Refer"},{"location":"level101/systems_design/scalability/#scalability-akf-scale-cube","text":"The Scale Cube is a model for segmenting services, defining microservices, and scaling products. It also creates a common language for teams to discuss scale related options in designing solutions. The following section talks about certain scaling patterns based on our inferences from the AKF cube","title":"Scalability - AKF Scale Cube"},{"location":"level101/systems_design/scalability/#scalability-horizontal-scaling","text":"Horizontal scaling stands for cloning of an application or service such that work can easily be distributed across instances with absolutely no bias. Let's see how our monolithic application improves with this principle Here DB is scaled separately from the application. This is to let you know each component\u2019s scaling capabilities can be different. Usually, web applications can be scaled by adding resources unless there is state stored inside the application. But DBs can be scaled only for Reads by adding more followers but Writes have to go to only one leader to make sure data is consistent. There are some DBs that support multi-leader writes but we are keeping them out of scope at this point. Apps should be able to differentiate between Reads and Writes to choose appropriate DB servers. Load balancers can split traffic between identical servers transparently. WHAT: Duplication of services or databases to spread transaction load. WHEN TO USE: Databases with a very high read-to-write ratio (5:1 or greater\u2014the higher the better). Because only read replicas of DBs can be scaled, not the Leader. HOW TO USE: Simply clone services and implement a load balancer. For databases, ensure that the accessing code understands the difference between a read and a write. WHY: Allows for the fast scale of transactions at the cost of duplicated data and functionality. KEY TAKEAWAYS: This is fast to implement, is a low cost from a developer effort perspective, and can scale transaction volumes nicely. However, they tend to be high cost from the perspective of the operational cost of data. The cost here means if we have 3 followers and 1 Leader DB, the same database will be stored as 4 copies in the 4 servers. Hence added storage cost","title":"Scalability - Horizontal scaling"},{"location":"level101/systems_design/scalability/#refer_1","text":"https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html","title":"Refer"},{"location":"level101/systems_design/scalability/#scalability-pattern-load-balancing","text":"Improves the distribution of workloads across multiple computing resources, such as computers, a computer cluster, network links, central processing units, or disk drives. A commonly used technique is load balancing traffic across identical server clusters. A similar philosophy is used to load balance traffic across network links by ECMP , disk drives by RAID ,etc Aims to optimize resource use, maximize throughput, minimize response time, and avoid overload of any single resource. Using multiple components with load balancing instead of a single component may increase reliability and availability through redundancy. In our updated architecture diagram we have 4 servers to handle app traffic instead of a single server The device or system that performs load balancing is called a load balancer, abbreviated as LB.","title":"Scalability Pattern - Load Balancing"},{"location":"level101/systems_design/scalability/#refer_2","text":"https://en.wikipedia.org/wiki/Load_balancing_(computing) https://blog.envoyproxy.io/introduction-to-modern-network-load-balancing-and-proxying-a57f6ff80236 https://learning.oreilly.com/library/view/load-balancing-in/9781492038009/ https://learning.oreilly.com/library/view/practical-load-balancing/9781430236801/ http://shop.oreilly.com/product/9780596000509.do","title":"Refer"},{"location":"level101/systems_design/scalability/#scalability-pattern-lb-tasks","text":"What does an LB do?","title":"Scalability Pattern - LB Tasks"},{"location":"level101/systems_design/scalability/#service-discovery","text":"What backends are available in the system? In our architecture, 4 servers are available to serve App traffic. LB acts as a single endpoint that clients can use transparently to reach one of the 4 servers.","title":"Service discovery:"},{"location":"level101/systems_design/scalability/#health-checking","text":"What backends are currently healthy and available to accept requests? If one out of the 4 App servers turns bad, LB should automatically short circuit the path so that clients don\u2019t sense any application downtime","title":"Health checking:"},{"location":"level101/systems_design/scalability/#load-balancing","text":"What algorithm should be used to balance individual requests across the healthy backends? There are many algorithms to distribute traffic across one of the four servers. Based on observations/experience, SRE can pick the algorithm that suits their pattern","title":"Load balancing:"},{"location":"level101/systems_design/scalability/#scalability-pattern-lb-methods","text":"Common Load Balancing Methods","title":"Scalability Pattern - LB Methods"},{"location":"level101/systems_design/scalability/#least-connection-method","text":"directs traffic to the server with the fewest active connections. Most useful when there are a large number of persistent connections in the traffic unevenly distributed between the servers. Works if clients maintain long-lived connections","title":"Least Connection Method"},{"location":"level101/systems_design/scalability/#least-response-time-method","text":"directs traffic to the server with the fewest active connections and the lowest average response time. Here response time is used to provide feedback of the server\u2019s health","title":"Least Response Time Method"},{"location":"level101/systems_design/scalability/#round-robin-method","text":"rotates servers by directing traffic to the first available server and then moves that server to the bottom of the queue. Most useful when servers are of equal specification and there are not many persistent connections.","title":"Round Robin Method"},{"location":"level101/systems_design/scalability/#ip-hash","text":"the IP address of the client determines which server receives the request. This can sometimes cause skewness in distribution but is useful if apps store some state locally and need some stickiness More advanced client/server-side example techniques - https://docs.nginx.com/nginx/admin-guide/load-balancer/ - http://cbonte.github.io/haproxy-dconv/2.2/intro.html#3.3.5 - https://twitter.github.io/finagle/guide/Clients.html#load-balancing","title":"IP Hash"},{"location":"level101/systems_design/scalability/#scalability-pattern-caching-content-delivery-networks-cdn","text":"CDNs are added closer to the client\u2019s location. If the app has static data like images, Javascript, CSS which don\u2019t change very often, they can be cached. Since our example is a content sharing site, static content can be cached in CDNs with a suitable expiry. WHAT: Use CDNs (content delivery networks) to offload traffic from your site. WHEN TO USE: When speed improvements and scale warrant the additional cost. HOW TO USE: Most CDNs leverage DNS to serve content on your site\u2019s behalf. Thus you may need to make minor DNS changes or additions and move content to be served from new subdomains. Eg media-exp1.licdn.com is a domain used by Linkedin to serve static content Here a CNAME points the domain to the DNS of the CDN provider dig media-exp1.licdn.com +short 2-01-2c3e-005c.cdx.cedexis.net. WHY: CDNs help offload traffic spikes and are often economical ways to scale parts of a site\u2019s traffic. They also often substantially improve page download times. KEY TAKEAWAYS: CDNs are a fast and simple way to offset the spikiness of traffic as well as traffic growth in general. Make sure you perform a cost-benefit analysis and monitor the CDN usage. If CDNs have a lot of cache misses, then we don\u2019t gain much from CDN and are still serving requests using our compute resources.","title":"Scalability Pattern - Caching - Content Delivery Networks (CDN)"},{"location":"level101/systems_design/scalability/#scalability-microservices","text":"This pattern represents the separation of work by service or function within the application. Microservices are meant to address the issues associated with growth and complexity in the code base and data sets. The intent is to create fault isolation as well as to reduce response times. Microservices can scale transactions, data sizes, and codebase sizes. They are most effective in scaling the size and complexity of your codebase. They tend to cost a bit more than horizontal scaling because the engineering team needs to rewrite services or, at the very least, disaggregate them from the original monolithic application. WHAT: Sometimes referred to as scale through services or resources, this rule focuses on scaling by splitting data sets, transactions, and engineering teams along verb (services) or noun (resources) boundaries. WHEN TO USE: Very large data sets where relations between data are not necessary. Large, complex systems where scaling engineering resources requires specialization. HOW TO USE: Split up actions by using verbs, or resources by using nouns, or use a mix. Split both the services and the data along the lines defined by the verb/noun approach. WHY: Allows for efficient scaling of not only transactions but also very large data sets associated with those transactions. It also allows for the efficient scaling of teams. KEY TAKEAWAYS: Microservices allow for efficient scaling of transactions, large data sets, and can help with fault isolation. It helps reduce the communication overhead of teams. The codebase becomes less complex as disjoint features are decoupled and spun as new services thereby letting each service scale independently specific to its requirement.","title":"Scalability - Microservices"},{"location":"level101/systems_design/scalability/#refer_3","text":"https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html","title":"Refer"},{"location":"level101/systems_design/scalability/#scalability-sharding","text":"This pattern represents the separation of work based on attributes that are looked up to or determined at the time of the transaction. Most often, these are implemented as splits by requestor, customer, or client. Very often, a lookup service or deterministic algorithm will need to be written for these types of splits. Sharding aids in scaling transaction growth, scaling instruction sets, and decreasing processing time (the last by limiting the data necessary to perform any transaction). This is more effective at scaling growth in customers or clients. It can aid with disaster recovery efforts, and limit the impact of incidents to only a specific segment of customers. Here the auth data is sharded based on user names so that DBs can respond faster as the amount of data DBs have to work on has drastically reduced during queries. There can be other ways to split Here the whole data center is split and replicated and clients are directed to a data center based on their geography. This helps in improving performance as clients are directed to the closest data center and performance increases as we add more data centers. There are some replication and consistency overhead with this approach one needs to be aware of. This also gives fault tolerance by rolling out test features to one site and rollback if there is an impact to that geography WHAT: This is very often a split by some unique aspect of the customer such as customer ID, name, geography, and so on. WHEN TO USE: Very large, similar data sets such as large and rapidly growing customer bases or when the response time for a geographically distributed customer base is important. HOW TO USE: Identify something you know about the customer, such as customer ID, last name, geography, or device, and split or partition both data and services based on that attribute. WHY: Rapid customer growth exceeds other forms of data growth, or you have the need to perform fault isolation between certain customer groups as you scale. KEY TAKEAWAYS: Shards are effective at helping you to scale customer bases but can also be applied to other very large data sets that can\u2019t be pulled apart using the microservices methodology.","title":"Scalability - Sharding"},{"location":"level101/systems_design/scalability/#refer_4","text":"https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html","title":"Refer"},{"location":"level101/systems_design/scalability/#applications-in-sre-role","text":"SREs in coordination with the network team work on how to map users' traffic to a particular site. https://engineering.linkedin.com/blog/2017/05/trafficshift--load-testing-at-scale SREs work closely with the Dev team to split monoliths to multiple microservices that are easy to run and manage SREs work on improving Load Balancers' reliability, service discovery, and performance SREs work closely to split Data into shards and manage data integrity and consistency. https://engineering.linkedin.com/espresso/introducing-espresso-linkedins-hot-new-distributed-document-store SREs work to set up, configure, and improve the CDN cache hit rate.","title":"Applications in SRE role"},{"location":"level102/containerization_and_orchestration/conclusion/","text":"Conclusion In this sub-module we have toured the world of containers starting from why we use containers, how containers evolved from the virtual machine past (though they are, in no means, obsolete) and how they are different from virtual machines. We then saw how containers are implemented with emphasis on cgroups and namespaces along with some hands-on exercises. Finally we concluded our journey with container orchestration where we learnt a bit of Kubernetes with some practical examples. Hope this module gives you enough knowledge and interest to continue learning and applying these technologies in greater depth!","title":"Conclusion"},{"location":"level102/containerization_and_orchestration/conclusion/#conclusion","text":"In this sub-module we have toured the world of containers starting from why we use containers, how containers evolved from the virtual machine past (though they are, in no means, obsolete) and how they are different from virtual machines. We then saw how containers are implemented with emphasis on cgroups and namespaces along with some hands-on exercises. Finally we concluded our journey with container orchestration where we learnt a bit of Kubernetes with some practical examples. Hope this module gives you enough knowledge and interest to continue learning and applying these technologies in greater depth!","title":"Conclusion"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/","text":"Introduction Docker has gained huge popularity among other container engines since it was released to the public in 2013. Here are some of the reasons why Docker so popular: Improved portability Docker containers can be shipped and run across environments be it local machine, on-prem or cloud instances in the form of Docker images. Compared to docker containers, LXC containers have more machine specifications. - Lighter weight Docker images are light weight compared to VM images. For example, an Ubuntu 18.04 VM size is about 3GB whereas the docker image is 45MB! Versioning of container images Docker supports maintaining multiple versions of images which makes it easier to look up the history of an image and even rollback. Reuse of images Since Docker images are in the form of layers, one image can be used as base on top of which new images are built. For example, Alpine is a light weight image (5MB) which is commonly used as a base image. Docker layers are managed using storage drivers . Community support Docker hub is a container registry where anyone logged in can upload or download a container image. Docker images of popular OS distros are regularly updated in docker hub and receive large community support. Let\u2019s look at some terms which come up during our discussion of Docker. Docker terminology Docker images Docker image contains the executable version of the application along with the dependencies (config files, libraries, binaries) required for the application to run as a standalone container. It can be understood as a snapshot of a container. Docker images are present as layers on top of the base layer. These layers are the ones that are versioned. The most recent version of layer is the one that is used on top of the base image. docker image ls lists the images present in the host machine. Docker containers Docker container is the running instance of the docker image. While images are static, containers created from the images can be executed into and interacted with. This is actually the \u201ccontainer\u201d from the previous sections of the module. docker run is the command used to instantiate containers from images. docker ps lists docker containers currently running in the host machine. Docker file It is a plain text file of instructions based on which an image is assembled by docker engine (daemon, to be precise). It contains information on base image, ENV variables to be injected. docker build is used to build images from dockerfile. Docker hub It is Docker\u2019s official container registry of images. Any user with a docker login can upload custom images to Docker hub using docker push and fetch images using docker pull . Having known the basic terminologies let\u2019s look at how docker engine works; how CLI commands are interpreted and container life-cycle is managed. Components of Docker engine Let\u2019s start with the diagram of Docker Engine to understand better: The docker engine follows a client-server architecture. It consists of 3 components: Docker client This is the component the user directly interacts with. When you execute docker commands which we saw earlier (push, pull, container ls, image ls) , we are actually using the docker client. A single docker client can communicate with multiple docker daemons. REST API Provides an interface for the docker client and daemon to communicate. Docker Daemon (server) This is the main component of the docker engine. It builds images from dockerfile, fetches images from docker registry, pushes images to the registry, stops, starts containers etc. It also manages networking between containers. LAB The official docker github provides labs at several levels for learning Docker. We're linking one of the labs which we found great for people beginning from scratch. Please follow the labs in this order: Setting up local environment for the labs Basics for using docker CLI Creating and containerizing a basic Flask app Here is another beginner level lab from Katacoda for dockerizing a node js application. You don\u2019t even need a local setup for this and it\u2019s easy to follow along. Advanced features of Docker While we have covered the basics of containerization and how a standalone application can be dockerized, processes in the real world need to communicate with each other. This need is particularly prevalent in applications which follow a microservice architecture. Docker networks Docker networks facilitate the interaction between containers running on the same hosts or even different hosts. There are several options provided through docker network command which specifies how the container interacts with the host and with other containers. The host option allows sharing of network stack with the host, bridge allows communication between containers running on the same host but not external to the host, overlay facilitates interaction between containers across hosts attached to the same network and macvlan which assigns a separate MAC address to a container for legacy containers are some important types of networks supported by Docker. This however is outside the scope of this module. The official documentation on docker networks itself is a good place to start. Volumes Apart from images, containers and networks, Docker also provides the option to create and mount volumes within containers. Generally, data within docker containers is non-persistent i.e once you kill the container the data is lost. Volumes are used for storing persistent data in containers. This KataKoda lab is a great place to start playing with volumes. In the next section we see how container deployments are orchestrated with Kubernetes.","title":"Containerization With Docker"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/#introduction","text":"Docker has gained huge popularity among other container engines since it was released to the public in 2013. Here are some of the reasons why Docker so popular: Improved portability Docker containers can be shipped and run across environments be it local machine, on-prem or cloud instances in the form of Docker images. Compared to docker containers, LXC containers have more machine specifications. - Lighter weight Docker images are light weight compared to VM images. For example, an Ubuntu 18.04 VM size is about 3GB whereas the docker image is 45MB! Versioning of container images Docker supports maintaining multiple versions of images which makes it easier to look up the history of an image and even rollback. Reuse of images Since Docker images are in the form of layers, one image can be used as base on top of which new images are built. For example, Alpine is a light weight image (5MB) which is commonly used as a base image. Docker layers are managed using storage drivers . Community support Docker hub is a container registry where anyone logged in can upload or download a container image. Docker images of popular OS distros are regularly updated in docker hub and receive large community support. Let\u2019s look at some terms which come up during our discussion of Docker.","title":"Introduction"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/#docker-terminology","text":"Docker images Docker image contains the executable version of the application along with the dependencies (config files, libraries, binaries) required for the application to run as a standalone container. It can be understood as a snapshot of a container. Docker images are present as layers on top of the base layer. These layers are the ones that are versioned. The most recent version of layer is the one that is used on top of the base image. docker image ls lists the images present in the host machine. Docker containers Docker container is the running instance of the docker image. While images are static, containers created from the images can be executed into and interacted with. This is actually the \u201ccontainer\u201d from the previous sections of the module. docker run is the command used to instantiate containers from images. docker ps lists docker containers currently running in the host machine. Docker file It is a plain text file of instructions based on which an image is assembled by docker engine (daemon, to be precise). It contains information on base image, ENV variables to be injected. docker build is used to build images from dockerfile. Docker hub It is Docker\u2019s official container registry of images. Any user with a docker login can upload custom images to Docker hub using docker push and fetch images using docker pull . Having known the basic terminologies let\u2019s look at how docker engine works; how CLI commands are interpreted and container life-cycle is managed.","title":"Docker terminology"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/#components-of-docker-engine","text":"Let\u2019s start with the diagram of Docker Engine to understand better: The docker engine follows a client-server architecture. It consists of 3 components: Docker client This is the component the user directly interacts with. When you execute docker commands which we saw earlier (push, pull, container ls, image ls) , we are actually using the docker client. A single docker client can communicate with multiple docker daemons. REST API Provides an interface for the docker client and daemon to communicate. Docker Daemon (server) This is the main component of the docker engine. It builds images from dockerfile, fetches images from docker registry, pushes images to the registry, stops, starts containers etc. It also manages networking between containers.","title":"Components of Docker engine"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/#lab","text":"The official docker github provides labs at several levels for learning Docker. We're linking one of the labs which we found great for people beginning from scratch. Please follow the labs in this order: Setting up local environment for the labs Basics for using docker CLI Creating and containerizing a basic Flask app Here is another beginner level lab from Katacoda for dockerizing a node js application. You don\u2019t even need a local setup for this and it\u2019s easy to follow along.","title":"LAB"},{"location":"level102/containerization_and_orchestration/containerization_with_docker/#advanced-features-of-docker","text":"While we have covered the basics of containerization and how a standalone application can be dockerized, processes in the real world need to communicate with each other. This need is particularly prevalent in applications which follow a microservice architecture. Docker networks Docker networks facilitate the interaction between containers running on the same hosts or even different hosts. There are several options provided through docker network command which specifies how the container interacts with the host and with other containers. The host option allows sharing of network stack with the host, bridge allows communication between containers running on the same host but not external to the host, overlay facilitates interaction between containers across hosts attached to the same network and macvlan which assigns a separate MAC address to a container for legacy containers are some important types of networks supported by Docker. This however is outside the scope of this module. The official documentation on docker networks itself is a good place to start. Volumes Apart from images, containers and networks, Docker also provides the option to create and mount volumes within containers. Generally, data within docker containers is non-persistent i.e once you kill the container the data is lost. Volumes are used for storing persistent data in containers. This KataKoda lab is a great place to start playing with volumes. In the next section we see how container deployments are orchestrated with Kubernetes.","title":"Advanced features of Docker"},{"location":"level102/containerization_and_orchestration/intro/","text":"Containers and orchestration Introduction Containers, Docker and Kubernetes are \"cool\" terms that are being spoken of by everyone involved with software in some way. Let's dive into each of these pieces of technology at enough depth to understand what the whole deal is about! In this module we talk about the ins and outs of containers: the internals and usage of containers; how they are implemented, how to containerize your application and finally, how to deploy containerized applications on a large scale without losing your sleep. We'll also get our hands dirty by trying out a few lab exercises. Prerequisites Basic knowledge of linux will be helpful understanding the internals of containers Basic knowledge of shell commands (will come handy when we're containerizing applications) Knowledge of running a basic web application. You can go through our Python And Web module to gain familiarity with this. What to expect from this course This module is divided into 3 sub-modules. In the first sub module, we will cover the internals of containerization and why they\u2019re used for. The second sub-module introduces Docker, a popular container engine and contains lab exercises on dockerizing a basic webapp. The last module talks about container orchestration with Kubernetes and some lab exercises to show how it makes the lives of SREs easy. What is not covered under this course We will not cover advanced docker and kubernetes concepts. However, we will be leading you to links and references from where you can pick them up as per your interest. Course Contents The following topics has been covered in this course: Introduction to containers What are containers Why containers Difference between virtual machines and containers How are containers implemented Namespaces Cgroups Container engines Containerization with Docker Introduction Basic docker terminology Components of Docker engine Hands-on Introduction to Advanced Docker Container orchestration with Kubernetes Introduction Motivation to use Kubernetes Kubernetes Architecture Hands-on Introduction to Advanced Kubernetes concepts Conclusion","title":"Introduction"},{"location":"level102/containerization_and_orchestration/intro/#containers-and-orchestration","text":"","title":"Containers and orchestration"},{"location":"level102/containerization_and_orchestration/intro/#introduction","text":"Containers, Docker and Kubernetes are \"cool\" terms that are being spoken of by everyone involved with software in some way. Let's dive into each of these pieces of technology at enough depth to understand what the whole deal is about! In this module we talk about the ins and outs of containers: the internals and usage of containers; how they are implemented, how to containerize your application and finally, how to deploy containerized applications on a large scale without losing your sleep. We'll also get our hands dirty by trying out a few lab exercises.","title":"Introduction"},{"location":"level102/containerization_and_orchestration/intro/#prerequisites","text":"Basic knowledge of linux will be helpful understanding the internals of containers Basic knowledge of shell commands (will come handy when we're containerizing applications) Knowledge of running a basic web application. You can go through our Python And Web module to gain familiarity with this.","title":"Prerequisites"},{"location":"level102/containerization_and_orchestration/intro/#what-to-expect-from-this-course","text":"This module is divided into 3 sub-modules. In the first sub module, we will cover the internals of containerization and why they\u2019re used for. The second sub-module introduces Docker, a popular container engine and contains lab exercises on dockerizing a basic webapp. The last module talks about container orchestration with Kubernetes and some lab exercises to show how it makes the lives of SREs easy.","title":"What to expect from this course"},{"location":"level102/containerization_and_orchestration/intro/#what-is-not-covered-under-this-course","text":"We will not cover advanced docker and kubernetes concepts. However, we will be leading you to links and references from where you can pick them up as per your interest.","title":"What is not covered under this course"},{"location":"level102/containerization_and_orchestration/intro/#course-contents","text":"The following topics has been covered in this course: Introduction to containers What are containers Why containers Difference between virtual machines and containers How are containers implemented Namespaces Cgroups Container engines Containerization with Docker Introduction Basic docker terminology Components of Docker engine Hands-on Introduction to Advanced Docker Container orchestration with Kubernetes Introduction Motivation to use Kubernetes Kubernetes Architecture Hands-on Introduction to Advanced Kubernetes concepts Conclusion","title":"Course Contents"},{"location":"level102/containerization_and_orchestration/intro_to_containers/","text":"What are containers Here's a popular definition of containers according to Docker , a popular containerization engine : A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another Let's break this down. A container is your code bundled along with its entire runtime environment. That includes your system libraries, binaries and config files needed for your application to run. Why containers You might wonder why we need to pack your application along with its dependencies. This is where the second part of the definition comes, ...so the application runs quickly and reliably from one computing environment to another. Developers usually write code in their dev environment (or local machine), test it in one or two staging/test environments before pushing their code into production. Ideally, for reliably testing applications before pushing to production, we need all these environments to be uniform to a tee (underlying OS, system libraries etc). Of course, the ideal is hard to achieve especially when we're using a mix of on-prem (complete control) and cloud infrastructure providers (more restrictive in terms of control of hardware and security options), a scenario which is more common today. This is exactly why we need to package not only the code but also the dependencies; so that your application runs reliably irrespective of which infrastructure or environment it runs on. We can run several containers on a single host. Due to how containers are implemented, each container has its own isolated environment within the same host. This means that a monolithic application can be broken down into micro-services and packaged into containers. Each microservice runs in the host machine in isolated environments. This is another reason why containers are used: separation of concerns . Providing isolated environments does not let the failure of one application in one container affect the other. This is called fault isolation . Isolation also gives the added benefit of increased security due to restricted visibility of processes in a container. Due to how most of the containerization solutions are implemented, we also have the option to cap the amount of resources consumed by applications running within a container. This is called resource limiting . Will will discuss this feature in more detail in the section on cgroups. Difference between virtual machines and containers Let's digress a little and go into some history. In the previous section we talked about how containers help us in achieving separation of concerns. Before the wide-spread usage of containers, virtualization was used for running applications in isolated environments in the same host (it\u2019s still being used today in some cases). In plain terms, virtualization is where we package software along with a copy of the OS on which it runs. This package is called a virtual machine (VM). The image of the OS bundled in the VM is called Guest OS. A component called Hypervisor sits between the Guest and the Host OS and is responsible for facilitating the access of the underlying OS\u2019s hardware to the Guest OS. You can learn more about hypervisors here . Similar to how multiple containers can be run in a single host machine, multiple VMs can be run on a single host and in this way, it\u2019s possible to run applications (or each microservice) in a separate VM and achieve separation of concerns. The main focus here is on the size of the VMs and containers. VMs come along with a copy of the guest operating system and therefore are heavy-weight compared to containers. If you\u2019re more interested in comparison of VMs and containers, you can check these articles from Backblaze and NetApp . While it is possible to run an operating system on a host with an incompatible kernel using hypervisors (e.g Windows 10 VM on CentOS 7), in cases where kernels can be shared (e.g Ubuntu on CentOS 7) containers are preferred over VMs due to the size factor. Sharing kernels, as you will see later, also gives containers many performance benefits over VMs like quicker boot-ups. Let\u2019s look at the diagram of how containers work. Comparing the two diagrams, we notice two things: Containers do not have a separate (guest) OS Container engine is the intermediary between containers and Host OS. It is used to facilitate the life-cycle of a container on the Host OS (it is not a necessity, however). The next section explains in detail how containers share the same operating system (kernel, to be precise) as the host machine and yet provide isolated environments for applications to run. How are containers implemented We\u2019ve talked about how containers, unlike virtual machines, share the same kernel as the host operating system and provide isolated environments for applications to run. This is achieved without the overhead of running a guest operating system on the host OS, thanks to two features of linux kernel called cgroups and kernel namespaces. Now that we are touching upon the internals of containers, it would be appropriate to give a more technically accurate representation of what they are. A container is a linux process or a group of linux processes which is restricted in - visibility into processes outside the container (implemented using namespace) - quantity of resources it can use (implemented using cgroups) and - system calls that can be made from the container. Refer seccomp , if interested in knowing more. These restrictions are what make a containerized application remain isolated from other processes running in the same host. Now let\u2019s talk about namespaces and cgroup in a little more detail. Namespaces Visibility of processes inside a container should be restricted within itself. This is what linux namespaces do. The idea is that processes within a namespace can\u2019t affect those which it can\u2019t \u201csee\u201d. Processes sharing a single namespace have identities, service and/or interfaces unique to the namespace they exist in. Here\u2019s a list of namespaces in linux: Mount Process groups sharing a mount namespace share a separate, private set of mount points and file system view. Any modifications made to these namespaced mount points are not visible outside the namespace. For example it is possible to have a /var within the a mount namespace which is different from /var in the host. PID A processes in a pid namespace have process ids which are unique only within the namespace. A process can be a root process (pid 1) in its own pid namespace and have an entire tree of processes under it. Network Each network namespace will have its own network device instances that can be configured with individual network addresses. Processes in the same network namespace can have their own ports and route tables. User User namespaces can have their own users and group ids. It\u2019s possible for a process using a non-privileged user in the host machine to have a root user identity within a user namespace. Cgroup Allows creation of cgroups which can be used only within the cgroup namespace. Cgroups will be covered in more detail in the following section. UTS This namespace has its own hostname and domain name IPC. Each IPC namespace has its own System V and POSIX message queues. As complex as it seems, creating namespaces in linux is quite simple. Let\u2019s see a quick demo to create a PID namespace. You\u2019ll need a linux based OS with sudoers permission to follow along. DEMO: namespaces First we check which processes are running in the host system (output varies from system to system). Note the process with pid 1. Let\u2019s create a PID namespace with the unshare command and create a bash process in the namespace You can see that ps aux (which itself is a process launched in the PID namespace so created) can only see processes within its own namespace. Hence, the output shows only 2 processes running within the namespace. Also note, the root process (pid 1) in the namespace is not init but it is the bash shell which we specified while creating the namespace. Let\u2019s create another process in the same namespace which sleeps for 1000 seconds in the background. In my case the pid of the sleep process is 44 within the PID namespace . On a separate terminal, check for the process id of the sleep process as seen from the host. Note the difference in pid (23844 in the host and 44 within the namespace) though both refer to the same process (start time and all other attributes are same). It\u2019s also possible to nest namespaces i.e create a pid namespace from another pid namespace. Try out sudo nsenter -t 23844 --pid -r bash to reenter the namespace and create another pid namespace within it. It should be fun to do! Cgroups A cgroup can be defined as a set of processes whose usage of resources is metered and monitored. The resources can be memory pages, disk i/o, CPU etc. In fact, cgroups are classified based on which resource the limit is imposed on and nature of action taken when a limit is violated. The component in the cgroup which tracks resource utilization and controls the behaviour of processes in a cgroup is called resource-subsystem or resource controller. Following is the set of resource controllers and their function according to RHEL\u2019s introduction to cgroups : blkio \u2014 this subsystem sets limits on input/output access to and from block devices such as physical drives (disk, solid state, or USB). cpu \u2014 this subsystem uses the scheduler to provide cgroup processes access to the CPU. cpuacct \u2014 this subsystem generates automatic reports on CPU resources used by processes in a cgroup. cpuset \u2014 this subsystem assigns individual CPUs (on a multicore system) and memory nodes to processes in a cgroup. devices \u2014 this subsystem allows or denies access to devices by processes in a cgroup. freezer \u2014 this subsystem suspends or resumes processes in a cgroup. memory \u2014 this subsystem sets limits on memory use by processes in a cgroup and generates automatic reports on memory resources used by those processes. Cgroups follow a hierarchical, tree-like structure for each resource controller i.e one cgroup exists for each controller. Each cgroup in a hierarchy inherits certain attributes (e.g limits) from its parent cgroup. Let\u2019s try out a quick demo with memory cgroups to wrap our heads around the above ideas. You\u2019ll need a linux based OS (here, RedHat) with sudo permission to follow along. DEMO: cgroups Let\u2019s start by checking if cgroup tools are installed in your machine. Execute mount | grep \"^cgroup\" . If you have the tools installed you\u2019ll see a output like this: If not, install the tools with sudo yum install libcgroup-tools -y . Now, we create a memory cgroup called mem_group with \u201croot\u201d as the owner of the cgroup. Command executed sudo cgcreate -a root -g memory:mem_group . Verify that cgroup is created. /sys/fs/cgroup/ is the pseudo filesystem where a newly created cgroup is added as a sub-group. Memory cgroup puts a limit on the memory usage of processes in the cgroup. Let\u2019s see what the limits are for mem_group. The file for checking the memory limit is memory.limit_in_bytes( more information here , if you\u2019re interested). Note that mem_group has inherited the limit from its parent cgroup Now, let\u2019s reduce the memory usage limit to 20KB for the purpose of our demo (the actual limit is rounded off to the nearest power of 2). This limit is too low and hence most of the processes attached to mem_group should be OOM killed. Create a new shell and attach it to the cgroup. We need sudo permissions for this. The process is OOM killed as expected. You can confirm the same with dmesg logs (mm_fault_error). If you want to try out a more in-depth exercise on cgroups, check out this tutorial from Geeks for Geeks . Let\u2019s come back to containers again. Containers share the same kernel as the underlying host operating system and provide an isolated environment of the application within. Cgroups help in managing resources used by processes within a container and namespaces help isolate network stack, pids, users, group ids and mount points in a container from another container running on the same host. Of course, there are more components to containers which truly make it fully functional but that discussion is out of scope of this module. Container engine Container engines ease the process of creating and managing containers in a host machine. How? The container creation workflow typically begins with a container image. A container image is a packaged, portable version of the target application bundled with all dependencies for it to run. These container images are either available on the host machine (container host) from previous builds or need to be pulled from a remote repository of images. Sometimes the container engine might need to build the container image from a set of instructions. Finally once the container image is fetched/built, the container engine unpacks the image and creates an isolated environment for the application as per the image specifications. The files in the container image are then mounted to the isolated environment to get the application up and running within the container. There are several container engines available like Docker, RKT, LXC (one of the first container engines) which require different image formats (Docker, LXD). OCI (Open Container Initiative) is a collaborative project started by Docker that aims to standardize container runtime specifications and image formats across vendors. OCI FAQ section is a good place to start if you\u2019re curious about this project. We will focus on Docker in the next section .","title":"Introduction To Containers"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#what-are-containers","text":"Here's a popular definition of containers according to Docker , a popular containerization engine : A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another Let's break this down. A container is your code bundled along with its entire runtime environment. That includes your system libraries, binaries and config files needed for your application to run.","title":"What are containers"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#why-containers","text":"You might wonder why we need to pack your application along with its dependencies. This is where the second part of the definition comes, ...so the application runs quickly and reliably from one computing environment to another. Developers usually write code in their dev environment (or local machine), test it in one or two staging/test environments before pushing their code into production. Ideally, for reliably testing applications before pushing to production, we need all these environments to be uniform to a tee (underlying OS, system libraries etc). Of course, the ideal is hard to achieve especially when we're using a mix of on-prem (complete control) and cloud infrastructure providers (more restrictive in terms of control of hardware and security options), a scenario which is more common today. This is exactly why we need to package not only the code but also the dependencies; so that your application runs reliably irrespective of which infrastructure or environment it runs on. We can run several containers on a single host. Due to how containers are implemented, each container has its own isolated environment within the same host. This means that a monolithic application can be broken down into micro-services and packaged into containers. Each microservice runs in the host machine in isolated environments. This is another reason why containers are used: separation of concerns . Providing isolated environments does not let the failure of one application in one container affect the other. This is called fault isolation . Isolation also gives the added benefit of increased security due to restricted visibility of processes in a container. Due to how most of the containerization solutions are implemented, we also have the option to cap the amount of resources consumed by applications running within a container. This is called resource limiting . Will will discuss this feature in more detail in the section on cgroups.","title":"Why containers"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#difference-between-virtual-machines-and-containers","text":"Let's digress a little and go into some history. In the previous section we talked about how containers help us in achieving separation of concerns. Before the wide-spread usage of containers, virtualization was used for running applications in isolated environments in the same host (it\u2019s still being used today in some cases). In plain terms, virtualization is where we package software along with a copy of the OS on which it runs. This package is called a virtual machine (VM). The image of the OS bundled in the VM is called Guest OS. A component called Hypervisor sits between the Guest and the Host OS and is responsible for facilitating the access of the underlying OS\u2019s hardware to the Guest OS. You can learn more about hypervisors here . Similar to how multiple containers can be run in a single host machine, multiple VMs can be run on a single host and in this way, it\u2019s possible to run applications (or each microservice) in a separate VM and achieve separation of concerns. The main focus here is on the size of the VMs and containers. VMs come along with a copy of the guest operating system and therefore are heavy-weight compared to containers. If you\u2019re more interested in comparison of VMs and containers, you can check these articles from Backblaze and NetApp . While it is possible to run an operating system on a host with an incompatible kernel using hypervisors (e.g Windows 10 VM on CentOS 7), in cases where kernels can be shared (e.g Ubuntu on CentOS 7) containers are preferred over VMs due to the size factor. Sharing kernels, as you will see later, also gives containers many performance benefits over VMs like quicker boot-ups. Let\u2019s look at the diagram of how containers work. Comparing the two diagrams, we notice two things: Containers do not have a separate (guest) OS Container engine is the intermediary between containers and Host OS. It is used to facilitate the life-cycle of a container on the Host OS (it is not a necessity, however). The next section explains in detail how containers share the same operating system (kernel, to be precise) as the host machine and yet provide isolated environments for applications to run.","title":"Difference between virtual machines and containers"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#how-are-containers-implemented","text":"We\u2019ve talked about how containers, unlike virtual machines, share the same kernel as the host operating system and provide isolated environments for applications to run. This is achieved without the overhead of running a guest operating system on the host OS, thanks to two features of linux kernel called cgroups and kernel namespaces. Now that we are touching upon the internals of containers, it would be appropriate to give a more technically accurate representation of what they are. A container is a linux process or a group of linux processes which is restricted in - visibility into processes outside the container (implemented using namespace) - quantity of resources it can use (implemented using cgroups) and - system calls that can be made from the container. Refer seccomp , if interested in knowing more. These restrictions are what make a containerized application remain isolated from other processes running in the same host. Now let\u2019s talk about namespaces and cgroup in a little more detail.","title":"How are containers implemented"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#namespaces","text":"Visibility of processes inside a container should be restricted within itself. This is what linux namespaces do. The idea is that processes within a namespace can\u2019t affect those which it can\u2019t \u201csee\u201d. Processes sharing a single namespace have identities, service and/or interfaces unique to the namespace they exist in. Here\u2019s a list of namespaces in linux: Mount Process groups sharing a mount namespace share a separate, private set of mount points and file system view. Any modifications made to these namespaced mount points are not visible outside the namespace. For example it is possible to have a /var within the a mount namespace which is different from /var in the host. PID A processes in a pid namespace have process ids which are unique only within the namespace. A process can be a root process (pid 1) in its own pid namespace and have an entire tree of processes under it. Network Each network namespace will have its own network device instances that can be configured with individual network addresses. Processes in the same network namespace can have their own ports and route tables. User User namespaces can have their own users and group ids. It\u2019s possible for a process using a non-privileged user in the host machine to have a root user identity within a user namespace. Cgroup Allows creation of cgroups which can be used only within the cgroup namespace. Cgroups will be covered in more detail in the following section. UTS This namespace has its own hostname and domain name IPC. Each IPC namespace has its own System V and POSIX message queues. As complex as it seems, creating namespaces in linux is quite simple. Let\u2019s see a quick demo to create a PID namespace. You\u2019ll need a linux based OS with sudoers permission to follow along.","title":"Namespaces"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#demo-namespaces","text":"First we check which processes are running in the host system (output varies from system to system). Note the process with pid 1. Let\u2019s create a PID namespace with the unshare command and create a bash process in the namespace You can see that ps aux (which itself is a process launched in the PID namespace so created) can only see processes within its own namespace. Hence, the output shows only 2 processes running within the namespace. Also note, the root process (pid 1) in the namespace is not init but it is the bash shell which we specified while creating the namespace. Let\u2019s create another process in the same namespace which sleeps for 1000 seconds in the background. In my case the pid of the sleep process is 44 within the PID namespace . On a separate terminal, check for the process id of the sleep process as seen from the host. Note the difference in pid (23844 in the host and 44 within the namespace) though both refer to the same process (start time and all other attributes are same). It\u2019s also possible to nest namespaces i.e create a pid namespace from another pid namespace. Try out sudo nsenter -t 23844 --pid -r bash to reenter the namespace and create another pid namespace within it. It should be fun to do!","title":"DEMO: namespaces"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#cgroups","text":"A cgroup can be defined as a set of processes whose usage of resources is metered and monitored. The resources can be memory pages, disk i/o, CPU etc. In fact, cgroups are classified based on which resource the limit is imposed on and nature of action taken when a limit is violated. The component in the cgroup which tracks resource utilization and controls the behaviour of processes in a cgroup is called resource-subsystem or resource controller. Following is the set of resource controllers and their function according to RHEL\u2019s introduction to cgroups : blkio \u2014 this subsystem sets limits on input/output access to and from block devices such as physical drives (disk, solid state, or USB). cpu \u2014 this subsystem uses the scheduler to provide cgroup processes access to the CPU. cpuacct \u2014 this subsystem generates automatic reports on CPU resources used by processes in a cgroup. cpuset \u2014 this subsystem assigns individual CPUs (on a multicore system) and memory nodes to processes in a cgroup. devices \u2014 this subsystem allows or denies access to devices by processes in a cgroup. freezer \u2014 this subsystem suspends or resumes processes in a cgroup. memory \u2014 this subsystem sets limits on memory use by processes in a cgroup and generates automatic reports on memory resources used by those processes. Cgroups follow a hierarchical, tree-like structure for each resource controller i.e one cgroup exists for each controller. Each cgroup in a hierarchy inherits certain attributes (e.g limits) from its parent cgroup. Let\u2019s try out a quick demo with memory cgroups to wrap our heads around the above ideas. You\u2019ll need a linux based OS (here, RedHat) with sudo permission to follow along.","title":"Cgroups"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#demo-cgroups","text":"Let\u2019s start by checking if cgroup tools are installed in your machine. Execute mount | grep \"^cgroup\" . If you have the tools installed you\u2019ll see a output like this: If not, install the tools with sudo yum install libcgroup-tools -y . Now, we create a memory cgroup called mem_group with \u201croot\u201d as the owner of the cgroup. Command executed sudo cgcreate -a root -g memory:mem_group . Verify that cgroup is created. /sys/fs/cgroup/ is the pseudo filesystem where a newly created cgroup is added as a sub-group. Memory cgroup puts a limit on the memory usage of processes in the cgroup. Let\u2019s see what the limits are for mem_group. The file for checking the memory limit is memory.limit_in_bytes( more information here , if you\u2019re interested). Note that mem_group has inherited the limit from its parent cgroup Now, let\u2019s reduce the memory usage limit to 20KB for the purpose of our demo (the actual limit is rounded off to the nearest power of 2). This limit is too low and hence most of the processes attached to mem_group should be OOM killed. Create a new shell and attach it to the cgroup. We need sudo permissions for this. The process is OOM killed as expected. You can confirm the same with dmesg logs (mm_fault_error). If you want to try out a more in-depth exercise on cgroups, check out this tutorial from Geeks for Geeks . Let\u2019s come back to containers again. Containers share the same kernel as the underlying host operating system and provide an isolated environment of the application within. Cgroups help in managing resources used by processes within a container and namespaces help isolate network stack, pids, users, group ids and mount points in a container from another container running on the same host. Of course, there are more components to containers which truly make it fully functional but that discussion is out of scope of this module.","title":"DEMO: cgroups"},{"location":"level102/containerization_and_orchestration/intro_to_containers/#container-engine","text":"Container engines ease the process of creating and managing containers in a host machine. How? The container creation workflow typically begins with a container image. A container image is a packaged, portable version of the target application bundled with all dependencies for it to run. These container images are either available on the host machine (container host) from previous builds or need to be pulled from a remote repository of images. Sometimes the container engine might need to build the container image from a set of instructions. Finally once the container image is fetched/built, the container engine unpacks the image and creates an isolated environment for the application as per the image specifications. The files in the container image are then mounted to the isolated environment to get the application up and running within the container. There are several container engines available like Docker, RKT, LXC (one of the first container engines) which require different image formats (Docker, LXD). OCI (Open Container Initiative) is a collaborative project started by Docker that aims to standardize container runtime specifications and image formats across vendors. OCI FAQ section is a good place to start if you\u2019re curious about this project. We will focus on Docker in the next section .","title":"Container engine"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/","text":"Introduction Now we finally arrive at the most awaited part: running and managing containers at scale. So far, we have seen how Docker facilitates managing the life-cycle of containers and provides improved portability of applications. Docker does provide a solution for easing the deployment of containers on a large scale ( you can check out Docker Swarm, if interested) which integrates well with Docker containers. However, Kubernetes has become the de-facto tool for orchestrating the management of microservices (as containers) in large distributed environments. Let\u2019s see the points of interest for us, SREs, to use container orchestration tools and Kubernetes in particular. Motivation to use Kubernetes Ease of usage Though there is a steep learning curve associated with Kubernetes, once learnt , can be used as a one stop tool to manage your microservices. With a single command it is possible to deploy full fledged production ready environments. The desired state of an application needs to be recorded as a YAML manifest and Kubernetes manages the application for you. Ensure optimum usage of resources We can specify limits on resources used by each container in a deployment. We can also specify our choice of nodes where Kubernetes can schedule nodes to be deployed (e.g microservices with high CPU consumption can be instructed to be deployed in high compute nodes). Fault tolerance Self-healing is built into basic resource types of Kubernetes. This removes the headache of designing a fault tolerant application system from scratch. This applies especially to stateless applications. Infrastructure agnostic Kubernetes does not have vendor lock-in. It can be set up in multiple cloud environments or in on-prem data centers. Strong community support and documentation Kubernetes is open-source and many technologies like operators, service mesh etc. have been built by the community to manage and monitor Kubernetes-orchestrated applications better. Extensible and customisable We can build our custom resource definitions which fit our use case for managing applications and use Kubernetes to manage them (with custom controllers). You can check out this article if you are more interested in this topic. Architecture of Kubernetes Here\u2019s a diagram (from the official Kubernetes documentation ) containing different components which make Kubernetes work: Kubernetes components can be divided into two parts: control plane components and data plane components . A Kubernetes cluster consists of 1 or more host machines (called nodes) where the containers managed by Kubernetes are run. This constitutes the data plane (or node plane). The brain of Kuberentes which responds to events from the node plane (e.g create a pod, replicas mismatch) and does the main orchestration is called the control plane. All control plane components are typically installed in a master node. This master node does not run any user containers. The Kubernetes components themselves are run as containers wrapped in Pods (which is the most basic kubernetes resource object). Control plane components: kube-apiserver etcd kube-scheduler kube-controller-manager Node plane components kubelet kube-proxy This workflow might help you understand the working on components better: An SRE installs kubectl in their local machine. This is the client which interacts with the Kubernetes control plane (and hence the cluster). They create a YAML file, called manifest which specifies the desired state of the resource (e.g a deployment names \u201cfrontend\u201d needs 3 pods to always be running) When they issue a command to create objects based in the YAML file, the kubectl CLI tool sends a rest API request to the kube-apiserver . If the manifest is valid, it is stored as key value pairs in the etcd server on the control plane. kube-scheduler chooses which nodes to put the containers on (basically schedules them) There are controller processes (managed by kube-controller manager) which makes sure the current state of the cluster is equivalent to the desired state (here, 3 pods are indeed running in the cluster -> all is fine). On the node plane side, kubelet makes sure that pods are locally kept in running state. LAB Prerequisites The best way to start this exercise is to use a Katacoda kubernetes playground . A single node kubernetes cluster is already set up for you here for quick experimentation. You can also use this to play with docker. The environment gets torn down after 10 mins. So make sure that you save your files if you want to resume them. For persistent kubernetes clusters, you can set it up either in your local (using minikube ) or you can create a kubernetes cluster in Azure , GCP or any other cloud provider. Knowledge of YAML is nice to have for understanding the manifest files. Hands-on Lab 1: We are going to create an object called Pod which is the most basic unit for running a container in Kubernetes. Here, we will create a pod called \u2018nginx-pod\u201d which contains an nginx container called \u201cweb\u201d. We will also expose port 80 in the container so that we can interact with the nginx container. Save the below manifest in a file called nginx-pod.yaml apiVersion: v1 #[1] kind: Pod #[2] metadata: #[3] name: nginx-pod #[4] labels: #[5] app: nginx spec: #[6] containers: #[7] - name: web #[8] image: nginx #[9] ports: #[10] - name: web #[11] containerPort: 80 #[12] protocol: TCP #[13] Let\u2019s very briefly understand what\u2019s here: #[2] - kind: The \u201ckind\u201d of object that\u2019s being created. Here it is a Pod #[1] - apiVersion: The apiVersion of the \u201cPod\u201d resource. There could be minor changes in the values or keys in the yaml file if the version varies. #[3] - metadata: The metadata section of the file where pod labels and name is given #[6] - spec: This is the main part where the things inside the pod are defined These are not random key value pairs! They have to be interpretable by the kubeapiserver. You can check which key value pairs are optional/mandatory using kubectl explain pod command. Do try it out! Apply the manifest using the command kubectl apply -f nginx-pod.yaml . This creates the \u201cnginx-pod\u201d pod in the kubernetes cluster. Verify that the pod is in running state using kubectl get pod . It shows that nginx-pod is in Running state. 1/1 indicates that out of 1 out of 1 container(s) inside the pod is healthy. To check if the container running in \u201cnginx-pod\u201d is indeed \u201cweb\u201d we do the kubectl describe pod/nginx-pod command. This gives a lengthy output with a detailed description of the pod and the events that happened since the pod was created. This command is very useful for debugging. The part we are concerned here is this: You can see \u201cweb\u201d under the Containers section with Image as nginx. This is what we are looking for. How do we access the welcome page of nginx \u201cweb\u201d container? In the describe command you can see the IP address of the pod. Each pod is assigned an IP address on creation. Here, this is 10.244.1.3 Issue a curl request from the host curl 10.244.1.3:80 . You will get the welcome page! Let\u2019s say we want to use a specific tag of nginx (say 1.20.1) in the same pod i.e we want to modify some property of the pod. You can try editing nginx-pod.yaml (image: nginx:1.20.1 in #[9])and reapplying (step 2.). It will create a new container in the same pod with the new image. A container is created within the pod but the pod is the same. You can verify by checking the pod start time in describe command. It would show a much older time. You can actually see the nginx container by doing docker ps on the node01 terminal (if you\u2019re using Katacoda). What if we want to change the image to 1.20.1 for 1000 nginx pods? Stepping a little back, what if we want to create 1000 nginx pods. Of course, we can write a script but Kubernetes already offers a resource type called \u201cdeployment\u201d to manage large scale deployments better. Lab 2: We\u2019ll go a step further to see how we can create more than a single instance of the nginx pod at the same time. We will first create Save the below manifest in a file called nginx-deploy.yaml apiVersion: apps/v1 kind: Deployment #[1] metadata: name: nginx-deployment labels: app: nginx spec: replicas: 3 #[2] selector: matchLabels: app: nginx #[3] template: #[4] metadata: labels: app: nginx #[5] spec: containers: - name: web image: nginx ports: - name: web containerPort: 80 protocol: \"TCP\" You can see that it is similar to a pod definition till spec ( #[1] has Deployment as kind, api version is also different). Another thing interesting observation is the metadata and spec parts under #[4] is almost the same as the metadata and spec section under the Pod definition in Lab 1 (do go up and cross check this). What this implies is that we are deploying 3 nginx pods similar to Lab1. Also, the labels in matchLabels should be the same as labels under #[4] . Now apply the manifest using kubectl apply -f nginx-deploy.yaml Verify that 3 pods are indeed created. If you\u2019re curious, check the output of kubectl get deploy and kubectl describe deploy nginx-deployment . Delete one of the 3 pods using kubectl delete pod . After a few seconds again do kubectl get pod . You can see that a new pod is spawned to keep the total number of pods as 3 (see AGE 15s compared to others created 27 minutes ago)! This is a demonstration of how Kubernetes does fault tolerance. This is a property of Kubernetes deployment object (kill the pod from Lab1, it won\u2019t be respawned :) ) Let\u2019s say we want to increase the number of pods to 10. Try out kubectl scale deploy --replicas=10 nginx-deployment . You can see that 3/10 pods are older than the rest. This means Kubernetes has added 7 extra pods to scale the deployment to 10. This shows how simple it is to scale up and scale down containers using Kubernetes. Let\u2019s put all these pods behind a ClusterIP service. Execute kubectl expose deployment nginx-deployment --name=nginx-service . Curl the IP corresponding to 10.96.114.184. This curl request reaches one of the 10 pods in the deployment \u201cnginx-deployment\u201d in a round robin fashion. What happens when we execute the expose command is that a kubernetes Service is created of type Cluster IP so that all the pods behind this service are accessible through a single local IP (10.96.114.184, here). It is possible to have a public IP instead (i.e an actual external load balancer) by creating a Service of type LoadBalancer . Do feel free to play around with it! The above exercises a pretty good exposure to using Kubernetes to manage large scale deployments. Trust me, the process is very similar to the above for operating 1000 deployments and containers too! While a Deployment object is good enough for managing stateless applications, Kuberenetes provides other resources like Job, Daemonset, Cronjob, Statefulset etc. to manage special use cases. eAdditional labs: https://www.katacoda.com/lizrice/scenarios/kube-web https://www.katacoda.com/courses/kubernetes (Huge number of free follow-along exercises to play with Kubernetes) Advanced topics Most often than not, microservices orchestrated with Kubernetes contain dozens of instances of resources like deployment, services and configs. The manifests for these applications can be auto- generated with Helm templates and passed on as Helm charts. Similar to how we have PiPy for python packages there are remote repositories like Bitnami where Helm charts (e.g for setting up a production-ready Prometheus or Kafka with a single click) can be downloaded and used. This is a good place to begin . Kuberenetes provides the flexibility to create our custom resources (similar to Deployment or the Pod which we saw). For instance, if you want to create 5 instances of a resource with kind as SchoolOfSre you can! The only thing is that you have to write your custom resource for it. You can also build a custom operator for your custom resource to take certain actions on the resource instance. You can check here for more information.","title":"Orchestration With Kubernetes"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#introduction","text":"Now we finally arrive at the most awaited part: running and managing containers at scale. So far, we have seen how Docker facilitates managing the life-cycle of containers and provides improved portability of applications. Docker does provide a solution for easing the deployment of containers on a large scale ( you can check out Docker Swarm, if interested) which integrates well with Docker containers. However, Kubernetes has become the de-facto tool for orchestrating the management of microservices (as containers) in large distributed environments. Let\u2019s see the points of interest for us, SREs, to use container orchestration tools and Kubernetes in particular.","title":"Introduction"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#motivation-to-use-kubernetes","text":"Ease of usage Though there is a steep learning curve associated with Kubernetes, once learnt , can be used as a one stop tool to manage your microservices. With a single command it is possible to deploy full fledged production ready environments. The desired state of an application needs to be recorded as a YAML manifest and Kubernetes manages the application for you. Ensure optimum usage of resources We can specify limits on resources used by each container in a deployment. We can also specify our choice of nodes where Kubernetes can schedule nodes to be deployed (e.g microservices with high CPU consumption can be instructed to be deployed in high compute nodes). Fault tolerance Self-healing is built into basic resource types of Kubernetes. This removes the headache of designing a fault tolerant application system from scratch. This applies especially to stateless applications. Infrastructure agnostic Kubernetes does not have vendor lock-in. It can be set up in multiple cloud environments or in on-prem data centers. Strong community support and documentation Kubernetes is open-source and many technologies like operators, service mesh etc. have been built by the community to manage and monitor Kubernetes-orchestrated applications better. Extensible and customisable We can build our custom resource definitions which fit our use case for managing applications and use Kubernetes to manage them (with custom controllers). You can check out this article if you are more interested in this topic.","title":"Motivation to use Kubernetes"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#architecture-of-kubernetes","text":"Here\u2019s a diagram (from the official Kubernetes documentation ) containing different components which make Kubernetes work: Kubernetes components can be divided into two parts: control plane components and data plane components . A Kubernetes cluster consists of 1 or more host machines (called nodes) where the containers managed by Kubernetes are run. This constitutes the data plane (or node plane). The brain of Kuberentes which responds to events from the node plane (e.g create a pod, replicas mismatch) and does the main orchestration is called the control plane. All control plane components are typically installed in a master node. This master node does not run any user containers. The Kubernetes components themselves are run as containers wrapped in Pods (which is the most basic kubernetes resource object). Control plane components: kube-apiserver etcd kube-scheduler kube-controller-manager Node plane components kubelet kube-proxy This workflow might help you understand the working on components better: An SRE installs kubectl in their local machine. This is the client which interacts with the Kubernetes control plane (and hence the cluster). They create a YAML file, called manifest which specifies the desired state of the resource (e.g a deployment names \u201cfrontend\u201d needs 3 pods to always be running) When they issue a command to create objects based in the YAML file, the kubectl CLI tool sends a rest API request to the kube-apiserver . If the manifest is valid, it is stored as key value pairs in the etcd server on the control plane. kube-scheduler chooses which nodes to put the containers on (basically schedules them) There are controller processes (managed by kube-controller manager) which makes sure the current state of the cluster is equivalent to the desired state (here, 3 pods are indeed running in the cluster -> all is fine). On the node plane side, kubelet makes sure that pods are locally kept in running state.","title":"Architecture of Kubernetes"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#lab","text":"","title":"LAB"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#prerequisites","text":"The best way to start this exercise is to use a Katacoda kubernetes playground . A single node kubernetes cluster is already set up for you here for quick experimentation. You can also use this to play with docker. The environment gets torn down after 10 mins. So make sure that you save your files if you want to resume them. For persistent kubernetes clusters, you can set it up either in your local (using minikube ) or you can create a kubernetes cluster in Azure , GCP or any other cloud provider. Knowledge of YAML is nice to have for understanding the manifest files.","title":"Prerequisites"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#hands-on","text":"","title":"Hands-on"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#lab-1","text":"We are going to create an object called Pod which is the most basic unit for running a container in Kubernetes. Here, we will create a pod called \u2018nginx-pod\u201d which contains an nginx container called \u201cweb\u201d. We will also expose port 80 in the container so that we can interact with the nginx container. Save the below manifest in a file called nginx-pod.yaml apiVersion: v1 #[1] kind: Pod #[2] metadata: #[3] name: nginx-pod #[4] labels: #[5] app: nginx spec: #[6] containers: #[7] - name: web #[8] image: nginx #[9] ports: #[10] - name: web #[11] containerPort: 80 #[12] protocol: TCP #[13] Let\u2019s very briefly understand what\u2019s here: #[2] - kind: The \u201ckind\u201d of object that\u2019s being created. Here it is a Pod #[1] - apiVersion: The apiVersion of the \u201cPod\u201d resource. There could be minor changes in the values or keys in the yaml file if the version varies. #[3] - metadata: The metadata section of the file where pod labels and name is given #[6] - spec: This is the main part where the things inside the pod are defined These are not random key value pairs! They have to be interpretable by the kubeapiserver. You can check which key value pairs are optional/mandatory using kubectl explain pod command. Do try it out! Apply the manifest using the command kubectl apply -f nginx-pod.yaml . This creates the \u201cnginx-pod\u201d pod in the kubernetes cluster. Verify that the pod is in running state using kubectl get pod . It shows that nginx-pod is in Running state. 1/1 indicates that out of 1 out of 1 container(s) inside the pod is healthy. To check if the container running in \u201cnginx-pod\u201d is indeed \u201cweb\u201d we do the kubectl describe pod/nginx-pod command. This gives a lengthy output with a detailed description of the pod and the events that happened since the pod was created. This command is very useful for debugging. The part we are concerned here is this: You can see \u201cweb\u201d under the Containers section with Image as nginx. This is what we are looking for. How do we access the welcome page of nginx \u201cweb\u201d container? In the describe command you can see the IP address of the pod. Each pod is assigned an IP address on creation. Here, this is 10.244.1.3 Issue a curl request from the host curl 10.244.1.3:80 . You will get the welcome page! Let\u2019s say we want to use a specific tag of nginx (say 1.20.1) in the same pod i.e we want to modify some property of the pod. You can try editing nginx-pod.yaml (image: nginx:1.20.1 in #[9])and reapplying (step 2.). It will create a new container in the same pod with the new image. A container is created within the pod but the pod is the same. You can verify by checking the pod start time in describe command. It would show a much older time. You can actually see the nginx container by doing docker ps on the node01 terminal (if you\u2019re using Katacoda). What if we want to change the image to 1.20.1 for 1000 nginx pods? Stepping a little back, what if we want to create 1000 nginx pods. Of course, we can write a script but Kubernetes already offers a resource type called \u201cdeployment\u201d to manage large scale deployments better.","title":"Lab 1:"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#lab-2","text":"We\u2019ll go a step further to see how we can create more than a single instance of the nginx pod at the same time. We will first create Save the below manifest in a file called nginx-deploy.yaml apiVersion: apps/v1 kind: Deployment #[1] metadata: name: nginx-deployment labels: app: nginx spec: replicas: 3 #[2] selector: matchLabels: app: nginx #[3] template: #[4] metadata: labels: app: nginx #[5] spec: containers: - name: web image: nginx ports: - name: web containerPort: 80 protocol: \"TCP\" You can see that it is similar to a pod definition till spec ( #[1] has Deployment as kind, api version is also different). Another thing interesting observation is the metadata and spec parts under #[4] is almost the same as the metadata and spec section under the Pod definition in Lab 1 (do go up and cross check this). What this implies is that we are deploying 3 nginx pods similar to Lab1. Also, the labels in matchLabels should be the same as labels under #[4] . Now apply the manifest using kubectl apply -f nginx-deploy.yaml Verify that 3 pods are indeed created. If you\u2019re curious, check the output of kubectl get deploy and kubectl describe deploy nginx-deployment . Delete one of the 3 pods using kubectl delete pod . After a few seconds again do kubectl get pod . You can see that a new pod is spawned to keep the total number of pods as 3 (see AGE 15s compared to others created 27 minutes ago)! This is a demonstration of how Kubernetes does fault tolerance. This is a property of Kubernetes deployment object (kill the pod from Lab1, it won\u2019t be respawned :) ) Let\u2019s say we want to increase the number of pods to 10. Try out kubectl scale deploy --replicas=10 nginx-deployment . You can see that 3/10 pods are older than the rest. This means Kubernetes has added 7 extra pods to scale the deployment to 10. This shows how simple it is to scale up and scale down containers using Kubernetes. Let\u2019s put all these pods behind a ClusterIP service. Execute kubectl expose deployment nginx-deployment --name=nginx-service . Curl the IP corresponding to 10.96.114.184. This curl request reaches one of the 10 pods in the deployment \u201cnginx-deployment\u201d in a round robin fashion. What happens when we execute the expose command is that a kubernetes Service is created of type Cluster IP so that all the pods behind this service are accessible through a single local IP (10.96.114.184, here). It is possible to have a public IP instead (i.e an actual external load balancer) by creating a Service of type LoadBalancer . Do feel free to play around with it! The above exercises a pretty good exposure to using Kubernetes to manage large scale deployments. Trust me, the process is very similar to the above for operating 1000 deployments and containers too! While a Deployment object is good enough for managing stateless applications, Kuberenetes provides other resources like Job, Daemonset, Cronjob, Statefulset etc. to manage special use cases. eAdditional labs: https://www.katacoda.com/lizrice/scenarios/kube-web https://www.katacoda.com/courses/kubernetes (Huge number of free follow-along exercises to play with Kubernetes)","title":"Lab 2:"},{"location":"level102/containerization_and_orchestration/orchestration_with_kubernetes/#advanced-topics","text":"Most often than not, microservices orchestrated with Kubernetes contain dozens of instances of resources like deployment, services and configs. The manifests for these applications can be auto- generated with Helm templates and passed on as Helm charts. Similar to how we have PiPy for python packages there are remote repositories like Bitnami where Helm charts (e.g for setting up a production-ready Prometheus or Kafka with a single click) can be downloaded and used. This is a good place to begin . Kuberenetes provides the flexibility to create our custom resources (similar to Deployment or the Pod which we saw). For instance, if you want to create 5 instances of a resource with kind as SchoolOfSre you can! The only thing is that you have to write your custom resource for it. You can also build a custom operator for your custom resource to take certain actions on the resource instance. You can check here for more information.","title":"Advanced topics"},{"location":"level102/system_troubleshooting_and_performance/conclusion/","text":"Complex systems have many factors which can go wrong. It can be a bad design & architecture, poorly managed code, poor policies around different caches, bad DB queries or architecture, improper use of resources, or bad OS version, poorly monitored system, datacenter issues, network faults, and many more, Any of these can go wrong. As an SRE, Knowing important tools/commands, best practices, profiling, benchmarking and scaling can help you with faster troubleshooting and performance improvement of the overall system. Further readings Here are some links from the LinkedIn Engineering Blog, as written by LinkedIn engineers, about firefighting they did, ensuring site up 24x7x365. Taming memory fragmentation in Venice with Jemalloc Intro: Every Day Is Monday in Operations Fixing Linux filesystem performance regressions The impact of slow NFS on data systems","title":"Conclusion"},{"location":"level102/system_troubleshooting_and_performance/conclusion/#further-readings","text":"Here are some links from the LinkedIn Engineering Blog, as written by LinkedIn engineers, about firefighting they did, ensuring site up 24x7x365. Taming memory fragmentation in Venice with Jemalloc Intro: Every Day Is Monday in Operations Fixing Linux filesystem performance regressions The impact of slow NFS on data systems","title":"Further readings"},{"location":"level102/system_troubleshooting_and_performance/important-tools/","text":"Important linux commands Having knowledge of following commands will help find issues faster. Elaborating each command in detail is out of scope, please look for man pages or online for more information and examples around the same. For logs parsing -: grep, sed, awk, cut, tail, head For network checks -: nc, netstat, traceroute/6, mtr, ping/6, route, tcpdump, ss, ip For DNS -: dig, host, nslookup For tracing system call -: strace For parallel executions over ssh -: gnu parallel, xargs + ssh. For http/s checks -: curl, wget For list of open files -: lsof For modifying attributes of the system kernel -: sysctl In case of distributed systems, some good third party tools can help to execute commands/instructions on many hosts at once, like: SSH based tools ClusterSSH : Cluster ssh can help you run a command in parallel on many hosts at once. Ansible : It allows you to write ansible playbooks which you can run on hundreds/thousands of hosts at the same time. Agent Based tools Saltstack : Is a configuration, state and remote execution framework, provides a wide variety of flexibility to users to execute modules on large numbers of hosts at once. Puppet : Is an automated administrative engine for your Linux, Unix, and Windows systems, performs administrative tasks. Log analysis tools These can help in writing SQL type queries for parsing, analysing logs and provide an easy UI interface to create dashboards which can render various types of charts based on defined queries. ELK : Elasticsearch, Logstash and Kibana, provide package of tools and services to allow, parse logs, index logs and analyse logs easily and quickly. Once logs/data is parsed/filtered through logstash and indexed in elasticsearch, one can create dynamic dashboards in Kibana in a matter of minutes. Such provides easy analysis and correlation on application errors/exceptions/warnings. Azure kusto : Azure kusto is a cloud based service similar to Elasticsearch and Kibana, it allows easy indexing of heavy logs, provides SQL type interface for writing queries, and an interface to create dynamic dashboards.","title":"Important Tools"},{"location":"level102/system_troubleshooting_and_performance/important-tools/#important-linux-commands","text":"Having knowledge of following commands will help find issues faster. Elaborating each command in detail is out of scope, please look for man pages or online for more information and examples around the same. For logs parsing -: grep, sed, awk, cut, tail, head For network checks -: nc, netstat, traceroute/6, mtr, ping/6, route, tcpdump, ss, ip For DNS -: dig, host, nslookup For tracing system call -: strace For parallel executions over ssh -: gnu parallel, xargs + ssh. For http/s checks -: curl, wget For list of open files -: lsof For modifying attributes of the system kernel -: sysctl In case of distributed systems, some good third party tools can help to execute commands/instructions on many hosts at once, like: SSH based tools ClusterSSH : Cluster ssh can help you run a command in parallel on many hosts at once. Ansible : It allows you to write ansible playbooks which you can run on hundreds/thousands of hosts at the same time. Agent Based tools Saltstack : Is a configuration, state and remote execution framework, provides a wide variety of flexibility to users to execute modules on large numbers of hosts at once. Puppet : Is an automated administrative engine for your Linux, Unix, and Windows systems, performs administrative tasks.","title":"Important linux commands"},{"location":"level102/system_troubleshooting_and_performance/important-tools/#log-analysis-tools","text":"These can help in writing SQL type queries for parsing, analysing logs and provide an easy UI interface to create dashboards which can render various types of charts based on defined queries. ELK : Elasticsearch, Logstash and Kibana, provide package of tools and services to allow, parse logs, index logs and analyse logs easily and quickly. Once logs/data is parsed/filtered through logstash and indexed in elasticsearch, one can create dynamic dashboards in Kibana in a matter of minutes. Such provides easy analysis and correlation on application errors/exceptions/warnings. Azure kusto : Azure kusto is a cloud based service similar to Elasticsearch and Kibana, it allows easy indexing of heavy logs, provides SQL type interface for writing queries, and an interface to create dynamic dashboards.","title":"Log analysis tools"},{"location":"level102/system_troubleshooting_and_performance/introduction/","text":"System troubleshooting and performance improvements Prerequisites Linux Basics System design Basic Networking Metrics and Monitoring What to expect from this course This brief course tries to provide a general introduction on how to troubleshoot system issues, like analysing api failures, resource utilization, network issues, hardware and OS issues. Course also briefs on profiling and benchmarking to measure overall system performance. What is not covered under this course This course does not cover following -: System Design and Architecture. Programming practices. Metrics and Monitoring. OS basics. Course Contents Introduction Troubleshooting Troubleshooting Flowchart General Practices General Host issues Important tools to know Important linux commands Log analysis tools Performance improvements Performance analysis commands Profiling tools Benchmarking Scaling Troubleshooting Example Conclusion Further readings Introduction Troubleshooting is an important part of operations & development. It can\u2019t be learned by just reading one article or completing a course online, Its a continuous learning process, one learns it during :- Daily operations and development. Finding & Fixing application bugs. Finding & Fixing system & network issues. Performance analysis and improvements. And more. From an SRE\u2019s perspective, It is expected that they are aware of certain topics upfront to be able to troubleshoot problems around single or distributed systems. Know your resources well, understand host specifications, liks CPU, Memory, Network, Disk etc. Understand system design and architecture. Ensure important metrics are being collected/rendered properly. There was a famous quote by HP founders - \u201cWhat gets measured gets fixed\u201d If system components and performance metrics are captured thoroughly then there is a high chance of success in troubleshooting an issue, at its earliest. Scope There is no common approach to troubleshoot different types of applications or services, the failure can occur at any layer of it. We will keep the scope of this work to a web api service type only. Note -: Linux ecosystem is wide, there are hundreds of tools and utilities which can help with system troubleshooting, each comes with its own set of benefits and functionalities. We will cover some of the known tools, either already available with Linux or are available in the open source world. Detailed explanation of mentioned tools in this doc is out of scope, please explore the internet or man pages for more examples and documentation around the same.","title":"Introduction"},{"location":"level102/system_troubleshooting_and_performance/introduction/#system-troubleshooting-and-performance-improvements","text":"","title":"System troubleshooting and performance improvements"},{"location":"level102/system_troubleshooting_and_performance/introduction/#prerequisites","text":"Linux Basics System design Basic Networking Metrics and Monitoring","title":"Prerequisites"},{"location":"level102/system_troubleshooting_and_performance/introduction/#what-to-expect-from-this-course","text":"This brief course tries to provide a general introduction on how to troubleshoot system issues, like analysing api failures, resource utilization, network issues, hardware and OS issues. Course also briefs on profiling and benchmarking to measure overall system performance.","title":"What to expect from this course"},{"location":"level102/system_troubleshooting_and_performance/introduction/#what-is-not-covered-under-this-course","text":"This course does not cover following -: System Design and Architecture. Programming practices. Metrics and Monitoring. OS basics.","title":"What is not covered under this course"},{"location":"level102/system_troubleshooting_and_performance/introduction/#course-contents","text":"Introduction Troubleshooting Troubleshooting Flowchart General Practices General Host issues Important tools to know Important linux commands Log analysis tools Performance improvements Performance analysis commands Profiling tools Benchmarking Scaling Troubleshooting Example Conclusion Further readings","title":"Course Contents"},{"location":"level102/system_troubleshooting_and_performance/introduction/#introduction","text":"Troubleshooting is an important part of operations & development. It can\u2019t be learned by just reading one article or completing a course online, Its a continuous learning process, one learns it during :- Daily operations and development. Finding & Fixing application bugs. Finding & Fixing system & network issues. Performance analysis and improvements. And more. From an SRE\u2019s perspective, It is expected that they are aware of certain topics upfront to be able to troubleshoot problems around single or distributed systems. Know your resources well, understand host specifications, liks CPU, Memory, Network, Disk etc. Understand system design and architecture. Ensure important metrics are being collected/rendered properly. There was a famous quote by HP founders - \u201cWhat gets measured gets fixed\u201d If system components and performance metrics are captured thoroughly then there is a high chance of success in troubleshooting an issue, at its earliest.","title":"Introduction"},{"location":"level102/system_troubleshooting_and_performance/introduction/#scope","text":"There is no common approach to troubleshoot different types of applications or services, the failure can occur at any layer of it. We will keep the scope of this work to a web api service type only. Note -: Linux ecosystem is wide, there are hundreds of tools and utilities which can help with system troubleshooting, each comes with its own set of benefits and functionalities. We will cover some of the known tools, either already available with Linux or are available in the open source world. Detailed explanation of mentioned tools in this doc is out of scope, please explore the internet or man pages for more examples and documentation around the same.","title":"Scope"},{"location":"level102/system_troubleshooting_and_performance/performance-improvements/","text":"Performance tools are an important part of development/operations lifecycle, Its highly important for understanding application behavior. SRE generally uses such tools to evaluate how well service will perform and make/suggest improvements accordingly. Performance analysis commands Most of these commands are a must to know for doing performance analysis of a system or service. top -: shows real-time view of running system, processes, threads etc. htop -: Similar to top command, but a bit more interactive then it. iotop -: An interactive disk I/O monitoring tool. vmstat -: Virtual memory statistics explorer. iostat -: Monitoring tool for input/output statistics for devices and partitions. free -: Tell info about physical memory and swap memory. sar -: System activity report, reports diff metrics such as cpu, disk, mem, network, etc. mpstat -: Display info about CPU utilization and performance. lsof -: Provides info about the list of open files, opened by which processes. perf -: Performance analysing tool. Profiling tools Profiling is an important part of performance analysis of the service. There are various profiler tools available, which can help figure most frequent code-paths, debugging, memory profiling, etc. These can generate the heatmap to understand the code performance when under load. FlameGraph : Flame graphs are a visualization of profiled software, allowing the most frequent code-paths to be identified quickly and accurately. Valgrind : It is a programming tool for memory debugging, memory leak detection, and profiling. Gprof : GNU profiler tool uses a hybrid of instrumentation and sampling. Instrumentation is used to collect function call information, and sampling is used to gather runtime profiling information. To know how LinkedIn performs On-Demand Profiling on its services, Read LinkedIn blog ODP: An Infrastructure for On-Demand Service Profiling Benchmarking It is a process of measuring the best performance of the service. Like how much QPS service can handle, its latency when load is increasing, host resource utilization, loadavg etc etc. The regression testing (i.e load testing) is a must before deploying the service to production. Some of known tools -: Apache Benchmark Tool, ab :, It simulate a high load on webapp and gather data for analysis Httperf : It sends requests to the web server at a specified rate and gathers stats. Increase till one finds the saturation point. Apache JMeter : It is a popular open-source tool to measure web application performance. JMeter is a java based application and not only a web server, but you can use it against PHP, Java, REST, etc. Wrk : It is another modern performance measurement tool to put a load on your web server and give you latency, request per second, transfer per second, etc. details. Locust : Easy to use, scriptable and scalable performance testing tool. Limitation -: Above tools help in synthetic load or stress testing, but such does not measure actual end user experience, It can\u2019t see how end user resources will affect application performance, it is due to lack of memory, CPU, or poor connectivity to the internet. To know how LinkedIn performs load testing across its fleet. Read : Eliminating toil with fully automated load testing And to know how LinkedIn makes use of Real Time Monitoring (RUM) data to overcome the limitations of load testing, and help improve overall experience for end users. Read : Monitor and Improve Web Performance Using RUM Data Visualization Scaling System designed optimally can perform up to a certain limit only, based on availability of resources. Continuous optimization is always needed to ensure optimum use of resources at its peak. With increasing QPS, Systems need to scale up. We can either scale vertically or horizontally. Vertical scalability has its limits as one can increase cpu, memory, disk, GPU and other specifications to certain limit only, whereas horizontal scalability can grow easily and infinitely given limitations imposed by application design and environment attributes. Scaling a web application will require some or all of the following -: Ease the server load by adding more hosts. Distributing the traffic across servers by using Load Balancers. Scale up DB by sharding the data and increasing read replicas. Here\u2019s a good read how LinkedIn scaled its application stack A Brief History of Scaling LinkedIn","title":"Performance Improvements"},{"location":"level102/system_troubleshooting_and_performance/performance-improvements/#performance-analysis-commands","text":"Most of these commands are a must to know for doing performance analysis of a system or service. top -: shows real-time view of running system, processes, threads etc. htop -: Similar to top command, but a bit more interactive then it. iotop -: An interactive disk I/O monitoring tool. vmstat -: Virtual memory statistics explorer. iostat -: Monitoring tool for input/output statistics for devices and partitions. free -: Tell info about physical memory and swap memory. sar -: System activity report, reports diff metrics such as cpu, disk, mem, network, etc. mpstat -: Display info about CPU utilization and performance. lsof -: Provides info about the list of open files, opened by which processes. perf -: Performance analysing tool.","title":"Performance analysis commands"},{"location":"level102/system_troubleshooting_and_performance/performance-improvements/#profiling-tools","text":"Profiling is an important part of performance analysis of the service. There are various profiler tools available, which can help figure most frequent code-paths, debugging, memory profiling, etc. These can generate the heatmap to understand the code performance when under load. FlameGraph : Flame graphs are a visualization of profiled software, allowing the most frequent code-paths to be identified quickly and accurately. Valgrind : It is a programming tool for memory debugging, memory leak detection, and profiling. Gprof : GNU profiler tool uses a hybrid of instrumentation and sampling. Instrumentation is used to collect function call information, and sampling is used to gather runtime profiling information. To know how LinkedIn performs On-Demand Profiling on its services, Read LinkedIn blog ODP: An Infrastructure for On-Demand Service Profiling","title":"Profiling tools"},{"location":"level102/system_troubleshooting_and_performance/performance-improvements/#benchmarking","text":"It is a process of measuring the best performance of the service. Like how much QPS service can handle, its latency when load is increasing, host resource utilization, loadavg etc etc. The regression testing (i.e load testing) is a must before deploying the service to production. Some of known tools -: Apache Benchmark Tool, ab :, It simulate a high load on webapp and gather data for analysis Httperf : It sends requests to the web server at a specified rate and gathers stats. Increase till one finds the saturation point. Apache JMeter : It is a popular open-source tool to measure web application performance. JMeter is a java based application and not only a web server, but you can use it against PHP, Java, REST, etc. Wrk : It is another modern performance measurement tool to put a load on your web server and give you latency, request per second, transfer per second, etc. details. Locust : Easy to use, scriptable and scalable performance testing tool. Limitation -: Above tools help in synthetic load or stress testing, but such does not measure actual end user experience, It can\u2019t see how end user resources will affect application performance, it is due to lack of memory, CPU, or poor connectivity to the internet. To know how LinkedIn performs load testing across its fleet. Read : Eliminating toil with fully automated load testing And to know how LinkedIn makes use of Real Time Monitoring (RUM) data to overcome the limitations of load testing, and help improve overall experience for end users. Read : Monitor and Improve Web Performance Using RUM Data Visualization","title":"Benchmarking"},{"location":"level102/system_troubleshooting_and_performance/performance-improvements/#scaling","text":"System designed optimally can perform up to a certain limit only, based on availability of resources. Continuous optimization is always needed to ensure optimum use of resources at its peak. With increasing QPS, Systems need to scale up. We can either scale vertically or horizontally. Vertical scalability has its limits as one can increase cpu, memory, disk, GPU and other specifications to certain limit only, whereas horizontal scalability can grow easily and infinitely given limitations imposed by application design and environment attributes. Scaling a web application will require some or all of the following -: Ease the server load by adding more hosts. Distributing the traffic across servers by using Load Balancers. Scale up DB by sharding the data and increasing read replicas. Here\u2019s a good read how LinkedIn scaled its application stack A Brief History of Scaling LinkedIn","title":"Scaling"},{"location":"level102/system_troubleshooting_and_performance/troubleshooting-example/","text":"In this section we will see an example of an issue and try to troubleshoot it, and at the end a few famous troubleshooting stories are shared, which were shared by LinkedIn engineers earlier. Example - Memory leak : Often memory leak issues go unnoticed until the service becomes unresponsive after running for some time (days, week or even month) until service is restarted or bug is fixed, In such cases, service memory usage will reflect in increasing order in the metric graph, something like this graph. Memory leak is mismanagement of memory allocations by application, where unneeded memory is not released, over the period of time objects continue to pile up in memory resulting in service crash. Generally such non-released objects get sorted by garbage collector automatically, but sometimes due to a bug it fails. Debugging helps in figuring where much of the application storage memory is being applied. Then, you start tracking and filter everything based on usage. In case, you find objects that aren\u2019t in use, but are referenced, you can get rid of them by deleting them to avoid memory leaks. In the case of python applications, it comes with inbuilt features like tracemalloc . This module can help pinpoint where an object was allocated first. Almost every language comes with a set of tools/libraries (inbuilt or external) which helps find memory issues. Similarly for Java there is a famous memory leak detection tool called Java VisualVM . Let\u2019s see how a dummy flask based web app with a memory leak bug, with every request its memory usage keeps increasing, and how we can use tracemalloc to capture the leak. Assumption -: A python virtual environment is created, and flask is installed in it. A bare minimum flask code with bug, read comments for more info Starting flask app On start, Its memory usage is around 26576 kb, i.e approx 26MB Now with every subsequent GET request, We can notice that process memory usage continues to increase slowly. Now lets try 10000 requests, to see if memory usage increases heavily. To hit a high number of requests, we use an Apache benchmarking tool called \u201cab\u201d . After 10000 hits, we can notice memory usage of flask app is jumped almost 15 times, i.e from initial 26576 KB to 419316 KB, i.e from roughly 26 MB to 419 MB , That\u2019s a huge jump for such a small webapp. Lets try the python tracemalloc module to try to understand the application memory allocations. Tracemalloc takes memory snapshots at a particular point, performing various statistics on the same. Adding a bare minimum code to our app.py file, no change in fetchuserdata.py file, it will allow us to capture tracemalloc snapshots whenever we will hit /capture uri. After restart of app.py (flask run) , we will - First hit http://127.0.0.1:5000/capture - Then hit http://127.0.0.1:5000/ 10000 times, for memory leak/s to take place. - Finally hit http://127.0.0.1:5000/capture again to take a snapshot to know which line has the most allocation. In the final snapshot, we noticed the exact module and lineno where most allocation happened. I.e fetchuserdata.py, line no 6, after 10000 hits, it is holding 419 MB of memory. Summary Above example shows how a bug can lead to memory leak, and how we can use tracemalloc to understand where it is. In real world applications are way more complex than the above dummy example, you must understand that using tracemalloc might degrade application performance somebit, due to tracemalloc own overheads. Be mindful about its use in production environments. If you are interested in digging deeper into Python Object Memory Allocation Internals and debugging memory leak, have a look at an Interesting talk by Sanket Patel in PyCon India 2019, Debug Memory Leak In Python Flask | Python Object Memory Allocation Internals","title":"Troubleshooting Example"},{"location":"level102/system_troubleshooting_and_performance/troubleshooting-example/#example-memory-leak","text":"Often memory leak issues go unnoticed until the service becomes unresponsive after running for some time (days, week or even month) until service is restarted or bug is fixed, In such cases, service memory usage will reflect in increasing order in the metric graph, something like this graph. Memory leak is mismanagement of memory allocations by application, where unneeded memory is not released, over the period of time objects continue to pile up in memory resulting in service crash. Generally such non-released objects get sorted by garbage collector automatically, but sometimes due to a bug it fails. Debugging helps in figuring where much of the application storage memory is being applied. Then, you start tracking and filter everything based on usage. In case, you find objects that aren\u2019t in use, but are referenced, you can get rid of them by deleting them to avoid memory leaks. In the case of python applications, it comes with inbuilt features like tracemalloc . This module can help pinpoint where an object was allocated first. Almost every language comes with a set of tools/libraries (inbuilt or external) which helps find memory issues. Similarly for Java there is a famous memory leak detection tool called Java VisualVM . Let\u2019s see how a dummy flask based web app with a memory leak bug, with every request its memory usage keeps increasing, and how we can use tracemalloc to capture the leak. Assumption -: A python virtual environment is created, and flask is installed in it. A bare minimum flask code with bug, read comments for more info Starting flask app On start, Its memory usage is around 26576 kb, i.e approx 26MB Now with every subsequent GET request, We can notice that process memory usage continues to increase slowly. Now lets try 10000 requests, to see if memory usage increases heavily. To hit a high number of requests, we use an Apache benchmarking tool called \u201cab\u201d . After 10000 hits, we can notice memory usage of flask app is jumped almost 15 times, i.e from initial 26576 KB to 419316 KB, i.e from roughly 26 MB to 419 MB , That\u2019s a huge jump for such a small webapp. Lets try the python tracemalloc module to try to understand the application memory allocations. Tracemalloc takes memory snapshots at a particular point, performing various statistics on the same. Adding a bare minimum code to our app.py file, no change in fetchuserdata.py file, it will allow us to capture tracemalloc snapshots whenever we will hit /capture uri. After restart of app.py (flask run) , we will - First hit http://127.0.0.1:5000/capture - Then hit http://127.0.0.1:5000/ 10000 times, for memory leak/s to take place. - Finally hit http://127.0.0.1:5000/capture again to take a snapshot to know which line has the most allocation. In the final snapshot, we noticed the exact module and lineno where most allocation happened. I.e fetchuserdata.py, line no 6, after 10000 hits, it is holding 419 MB of memory. Summary Above example shows how a bug can lead to memory leak, and how we can use tracemalloc to understand where it is. In real world applications are way more complex than the above dummy example, you must understand that using tracemalloc might degrade application performance somebit, due to tracemalloc own overheads. Be mindful about its use in production environments. If you are interested in digging deeper into Python Object Memory Allocation Internals and debugging memory leak, have a look at an Interesting talk by Sanket Patel in PyCon India 2019, Debug Memory Leak In Python Flask | Python Object Memory Allocation Internals","title":"Example - Memory leak :"},{"location":"level102/system_troubleshooting_and_performance/troubleshooting/","text":"Troubleshooting system failures can be tricky or tedious at times. In this practice we need to examine the end-to-end flow of a service, all its downstreams, analysing logs, memory leak, CPU usage, disk IO, network failures, hosts issues, etc. Knowing certain practices and tools can help figure & mitigate failures faster. Here\u2019s the high level troubleshooting flowchart -: Troubleshooting Flowchart General Practices Different systems require different approaches for finding issues. Scope of this is limited and given a problem, there can be many more points which can be looked into. Following points will look at some high level practices towards finding webapp failures and finding fixes for the same. Reproduce problem Try the broken request to reproduce the issue, Like try Hit http/s request which fails. Check the end to end flow of request and look for return codes, mostly 3xx, 4xx or 5xx . 3xx are mostly about redirections, 4xx are about unauthorized, bad request, forbidden, etc, And 5xx is mostly about server side issues. Based on the return code you can look for the next step. Client side issues are mainly about missing or buggy static contents, like javascript issues, bad image, broken json from an async call etc, such can result in incorrect page rendering on browsers. Gather Information Look for errors/exceptions in application logs, Like \"Can\u2019t Allocate Memory\" or OutOfMemoryError, Or Something like \"disk I/O error\", Or a DNS resolution error. Check application and host metrics, Look for anomalies in service and hosts graphs. Since when CPU usage has increased, since when memory usage increased, since when disk space is reduced Or Disk I/O is increased, when load average start shooting up etc. Please read the School of SRE link for more detail around metrics and monitoring . Look for recent code or config changes which possibly are breaking the system. Understand the problem Try correlating gathered data with recent actions, like an exception showing up in logs after config/code deployment. Is it due to the QPS increase? Is it bad SQL queries? Do recent code changes demand better or more hardware? Find a solution and apply a fix Based on the above findings, look for a quick fix if possible, For example like rolling back changes if errors/exceptions correlate. Try patching or hotfixing the code, probably in staging setup if you want to fix forward. Try to scale up the system, if high QPS is the reason for system failure, then try adding resources (compute, storage, memory, etc) as necessary. Optimize SQL queries if needed. Verify complete request flow Hit requests again and ensure returns are successful (return code 2xx). Check Logs ensure no more exceptions/errors, as found earlier. Ensure metrics are back to normal. General Host issues To Know if host health is fine or not, look for any hardware failures or its performance issues, one can try following -: Dmesg -: Shows recent errors / failures thrown by kernel. This help with knowing hardware failures if any ls commands -: lspci, lsblk, lscpu, lsscsi, These commands list out pci, disk, cpu information. /var/log/messages -: Shows system app/service related errors/warnings, also shows kernel issues. Smartd -: check disk health.","title":"Troubleshooting"},{"location":"level102/system_troubleshooting_and_performance/troubleshooting/#troubleshooting-flowchart","text":"","title":"Troubleshooting Flowchart"},{"location":"level102/system_troubleshooting_and_performance/troubleshooting/#general-practices","text":"Different systems require different approaches for finding issues. Scope of this is limited and given a problem, there can be many more points which can be looked into. Following points will look at some high level practices towards finding webapp failures and finding fixes for the same. Reproduce problem Try the broken request to reproduce the issue, Like try Hit http/s request which fails. Check the end to end flow of request and look for return codes, mostly 3xx, 4xx or 5xx . 3xx are mostly about redirections, 4xx are about unauthorized, bad request, forbidden, etc, And 5xx is mostly about server side issues. Based on the return code you can look for the next step. Client side issues are mainly about missing or buggy static contents, like javascript issues, bad image, broken json from an async call etc, such can result in incorrect page rendering on browsers. Gather Information Look for errors/exceptions in application logs, Like \"Can\u2019t Allocate Memory\" or OutOfMemoryError, Or Something like \"disk I/O error\", Or a DNS resolution error. Check application and host metrics, Look for anomalies in service and hosts graphs. Since when CPU usage has increased, since when memory usage increased, since when disk space is reduced Or Disk I/O is increased, when load average start shooting up etc. Please read the School of SRE link for more detail around metrics and monitoring . Look for recent code or config changes which possibly are breaking the system. Understand the problem Try correlating gathered data with recent actions, like an exception showing up in logs after config/code deployment. Is it due to the QPS increase? Is it bad SQL queries? Do recent code changes demand better or more hardware? Find a solution and apply a fix Based on the above findings, look for a quick fix if possible, For example like rolling back changes if errors/exceptions correlate. Try patching or hotfixing the code, probably in staging setup if you want to fix forward. Try to scale up the system, if high QPS is the reason for system failure, then try adding resources (compute, storage, memory, etc) as necessary. Optimize SQL queries if needed. Verify complete request flow Hit requests again and ensure returns are successful (return code 2xx). Check Logs ensure no more exceptions/errors, as found earlier. Ensure metrics are back to normal.","title":"General Practices"},{"location":"level102/system_troubleshooting_and_performance/troubleshooting/#general-host-issues","text":"To Know if host health is fine or not, look for any hardware failures or its performance issues, one can try following -: Dmesg -: Shows recent errors / failures thrown by kernel. This help with knowing hardware failures if any ls commands -: lspci, lsblk, lscpu, lsscsi, These commands list out pci, disk, cpu information. /var/log/messages -: Shows system app/service related errors/warnings, also shows kernel issues. Smartd -: check disk health.","title":"General Host issues"}]} \ No newline at end of file diff --git a/sitemap.xml b/sitemap.xml index 0d5478f..b54ff28 100644 --- a/sitemap.xml +++ b/sitemap.xml @@ -1,255 +1,279 @@ None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 daily None - 2021-08-04 + 2021-08-05 + daily + + None + 2021-08-05 + daily + + None + 2021-08-05 + daily + + None + 2021-08-05 + daily + + None + 2021-08-05 + daily + + None + 2021-08-05 + daily + + None + 2021-08-05 daily \ No newline at end of file diff --git a/sitemap.xml.gz b/sitemap.xml.gz index b57890754e81e6cda8f4c042277cef93642a9392..e656d777871d7fdf7dad1de1a6686afdef77d94e 100644 GIT binary patch delta 210 zcmaFJ_>7TVzMF&NEi=zVcDeda&RIcada*AVrB*mF=^BN8`4-gNX)D0z0_dh9sJ$2{qrYJ zR?l&WA7-ZB*^*_cV6m~aYkJ$3>~cOP1*=pf@AE*$$7|VA$vW?+1Lw=Kq||#e>WNY} zx18#3{SeRAEJ{K9U-XZtRlK~q50A86}djJ3c diff --git a/sre_community/index.html b/sre_community/index.html index ea55852..1900f32 100644 --- a/sre_community/index.html +++ b/sre_community/index.html @@ -1349,6 +1349,106 @@ + + + + + +