SQL order of execution

Introduction

  • In SQL in general and PostgreSQL in particular, the order of writing keywords in code (Lexical Order) is completely different from the order in which the Database Engine actually executes the statement (Logical Execution Order).
  • A query with full command structures like this will be parsed and executed by the Optimizer in a strict logical order from root (data source) to top (displayed results).
[ WITH [RECURSIVE] cte_name AS (...) ]
SELECT [ DISTINCT [ON (...)] ] columns
FROM source_table [ TABLESAMPLE ... ]
[ JOIN_clauses ]
[ WHERE raw_filter_conditions ]
[ GROUP BY { column | ROLLUP | CUBE | GROUPING SETS } ]
[ HAVING group_filter_conditions ]
[ WINDOW window_name AS (...) ]
[ { UNION | INTERSECT | EXCEPT } [ALL | DISTINCT] other_select_statement ]
[ ORDER BY sort_order ]
[ LIMIT limit_count ] [ OFFSET offset_count ]
[ FOR UPDATE / FOR SHARE [ SKIP LOCKED ] ];

Below is the execution order from the first step to the last step:

  • WITH / WITH RECURSIVE
    • This is the way to use CTE (Common Table Expressions) to execute statements inside the WITH block first to prepare temporary data tables
    • If it is RECURSIVE, it will run a loop to generate data until the stop condition is met.
  • FROM and TABLESAMPLE
    • Identify tables to retrieve data
    • If TABLESAMPLE is present, Postgres will only extract a random sample amount (for example 10% of table rows) for further processing, instead of the whole table.
  • JOIN clauses
    • Used to match data to create an expanded Cartesian product table, combining secondary tables into the source table based on operators (INNER, LEFT, RIGHT, FULL JOIN) and conditions after the ON keyword
    • At the end of this step, we have a temporary "super table" containing all columns of participating tables.
  • WHERE
    • Filters raw data by iterating through each row to keep rows that satisfy the WHERE condition, while non-satisfying rows are eliminated
    • Note that aggregate calculation functions (such as SUM, COUNT) cannot be used at this point because data has not been grouped yet.
  • GROUP BY
    • The remaining rows after filtering will be grouped based on specified columns.
    • Super functions like ROLLUP or CUBE will automatically generate subtotal and grand total rows at this step.
  • HAVING
    • Filters data after grouping based on aggregate functions
    • After groups are formed, the HAVING condition will be applied to eliminate groups that do not satisfy the condition.
  • WINDOW
    • Uses a combination of Aggregate Function (such as ROW_NUMBER(), RANK(), SUM(),...) and Window Function Clause (OVER) to compute aggregates based on 1 column
    • Unlike GROUP BY, this step computes based on partitions while keeping the original number of rows without collapsing rows.
  • SELECT and DISTINCT [ON]: Column extraction and deduplication
    • At this point, the Database calculates expressions and sets Alias based on the specified column list
    • If DISTINCT is present, it eliminates duplicate rows
    • With DISTINCT ON (...), it keeps the first unique row for each set of duplicate values.
  • Set operations UNION / INTERSECT / EXCEPT: Union, intersection and difference of statements.
    • If you have multiple SELECT statements connected by set operators, the Database takes the complete result of this statement to merge, intersect or subtract from the result of another SELECT statement
    • If ALL is used, it keeps everything, if DISTINCT is used (default), it scans to filter duplicates again.
  • ORDER BY: Display sorting
    • Final data is sorted according to specified columns or expressions.
    • Because this step runs after SELECT, Aliases defined in the SELECT step can be used for sorting.
  • LIMIT and OFFSET
    • Slices results, commonly used for data pagination.
    • Skips a number of initial rows (OFFSET) and keeps only the maximum requested number of rows (LIMIT)
    • This is performed at the very end to ensure returning only the exact amount of data needed by the client.
  • FOR UPDATE / FOR SHARE: Concurrency Control
    • After determining the exact final result rows to return to the user, Postgres locks those rows in memory for the Transaction
    • If SKIP LOCKED is used, it automatically skips rows currently locked by another session to avoid blocking.
    • In addition, there are other Row level locks with different lock levels

Detail

First, create Tables and Indexes as follows:

CREATE TABLE categories (
    category_id INT PRIMARY KEY,
    category_name VARCHAR(100) NOT NULL,
    parent_id INT REFERENCES categories(category_id)
);

CREATE TABLE products (
    product_id INT PRIMARY KEY,
    product_name VARCHAR(200) NOT NULL,
    category_id INT REFERENCES categories(category_id),
    price NUMERIC(12, 2) NOT NULL,
    stock_quantity INT NOT NULL DEFAULT 0
);

CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    customer_id INT NOT NULL,
    order_date TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    status VARCHAR(30) NOT NULL 
);

CREATE TABLE order_items (
    item_id INT PRIMARY KEY,
    order_id INT REFERENCES orders(order_id),
    product_id INT REFERENCES products(product_id),
    quantity INT NOT NULL,
    unit_price NUMERIC(12, 2) NOT NULL
);

Next is a comprehensive example describing the execution order:

WITH RECURSIVE category_tree AS (
    SELECT category_id, category_name, parent_id
    FROM categories
    WHERE category_id = 1
    
    UNION ALL
    
    SELECT c.category_id, c.category_name, c.parent_id
    FROM categories c
    JOIN category_tree ct ON c.parent_id = ct.category_id
),
target_orders AS (
    SELECT order_id, customer_id, order_date, status
    FROM orders
    WHERE status = 'PENDING'
)
SELECT 
    p.product_id,
    p.product_name,
    DATE(o.order_date) AS sales_date,
    SUM(oi.quantity) AS total_quantity_sold,
    SUM(oi.quantity * oi.unit_price) AS total_revenue,
    SUM(SUM(oi.quantity * oi.unit_price)) OVER w_daily AS daily_total_revenue,
    DENSE_RANK() OVER w_rank AS product_sales_rank
FROM order_items oi
JOIN target_orders o ON oi.order_id = o.order_id
JOIN products p ON oi.product_id = p.product_id
JOIN category_tree ct ON p.category_id = ct.category_id
WHERE oi.unit_price >= 1000.00
GROUP BY p.product_id, p.product_name, DATE(o.order_date)
HAVING SUM(oi.quantity) >= 1
WINDOW 
    w_daily AS (PARTITION BY DATE(o.order_date)),
    w_rank AS (PARTITION BY DATE(o.order_date) ORDER BY SUM(oi.quantity * oi.unit_price) DESC)
ORDER BY p.product_id, DATE(o.order_date), total_revenue DESC
LIMIT 100 OFFSET 0





The output will be as follows:

[
  {
    "Plan": {
      "Node Type": "Limit",
      "Parallel Aware": false,
      "Async Capable": false,
      "Actual Rows": 100.00,
      "Actual Loops": 1,
      "Disabled": false,
      "Plans": [
        {
          "Node Type": "Recursive Union",
          "Parent Relationship": "InitPlan",
          "Subplan Name": "CTE category_tree",
          "Parallel Aware": false,
          "Async Capable": false,
          "Actual Rows": 100.00,
          "Actual Loops": 1,
          "Disabled": false,
          "Storage": "Memory",
          "Maximum Storage": 35,
          "Plans": [
            {
              "Node Type": "Seq Scan",
              "Parent Relationship": "Outer",
              "Parallel Aware": false,
              "Async Capable": false,
              "Relation Name": "categories",
              "Alias": "categories",
              "Actual Rows": 1.00,
              "Actual Loops": 1,
              "Disabled": false,
              "Filter": "(category_id = 1)",
              "Rows Removed by Filter": 99
            },
            {
              "Node Type": "Hash Join",
              "Parent Relationship": "Inner",
              "Parallel Aware": false,
              "Async Capable": false,
              "Join Type": "Inner",
              "Actual Rows": 11.00,
              "Actual Loops": 9,
              "Disabled": false,
              "Inner Unique": false,
              "Hash Cond": "(c.parent_id = ct_1.category_id)",
              "Plans": [
                {
                  "Node Type": "Seq Scan",
                  "Parent Relationship": "Outer",
                  "Parallel Aware": false,
                  "Async Capable": false,
                  "Relation Name": "categories",
                  "Alias": "c",
                  "Actual Rows": 100.00,
                  "Actual Loops": 9,
                  "Disabled": false
                },
                {
                  "Node Type": "Hash",
                  "Parent Relationship": "Inner",
                  "Parallel Aware": false,
                  "Async Capable": false,
                  "Actual Rows": 11.11,
                  "Actual Loops": 9,
                  "Disabled": false,
                  "Hash Buckets": 1024,
                  "Original Hash Buckets": 1024,
                  "Hash Batches": 1,
                  "Original Hash Batches": 1,
                  "Peak Memory Usage": 9,
                  "Plans": [
                    {
                      "Node Type": "WorkTable Scan",
                      "Parent Relationship": "Outer",
                      "Parallel Aware": false,
                      "Async Capable": false,
                      "CTE Name": "category_tree",
                      "Alias": "ct_1",
                      "Actual Rows": 11.11,
                      "Actual Loops": 9,
                      "Disabled": false
                    }
                  ]
                }
              ]
            }
          ]
        },
        {
          "Node Type": "Sort",
          "Parent Relationship": "Outer",
          "Parallel Aware": false,
          "Async Capable": false,
          "Actual Rows": 100.00,
          "Actual Loops": 1,
          "Disabled": false,
          "Sort Key": ["p.product_id", "(date(orders.order_date))", "(sum(((oi.quantity)::numeric * oi.unit_price))) DESC"],
          "Sort Method": "top-N heapsort",
          "Sort Space Used": 47,
          "Sort Space Type": "Memory",
          "Plans": [
            {
              "Node Type": "WindowAgg",
              "Parent Relationship": "Outer",
              "Parallel Aware": false,
              "Async Capable": false,
              "Actual Rows": 1882.00,
              "Actual Loops": 1,
              "Disabled": false,
              "Window": "w_daily AS (PARTITION BY (date(orders.order_date)))",
              "Storage": "Memory",
              "Maximum Storage": 19,
              "Plans": [
                {
                  "Node Type": "WindowAgg",
                  "Parent Relationship": "Outer",
                  "Parallel Aware": false,
                  "Async Capable": false,
                  "Actual Rows": 1882.00,
                  "Actual Loops": 1,
                  "Disabled": false,
                  "Window": "w_rank AS (PARTITION BY (date(orders.order_date)) ORDER BY (sum(((oi.quantity)::numeric * oi.unit_price))) ROWS UNBOUNDED PRECEDING)",
                  "Storage": "Memory",
                  "Maximum Storage": 17,
                  "Plans": [
                    {
                      "Node Type": "Sort",
                      "Parent Relationship": "Outer",
                      "Parallel Aware": false,
                      "Async Capable": false,
                      "Actual Rows": 1882.00,
                      "Actual Loops": 1,
                      "Disabled": false,
                      "Sort Key": ["(date(orders.order_date))", "(sum(((oi.quantity)::numeric * oi.unit_price))) DESC"],
                      "Sort Method": "quicksort",
                      "Sort Space Used": 151,
                      "Sort Space Type": "Memory",
                      "Plans": [
                        {
                          "Node Type": "Aggregate",
                          "Strategy": "Hashed",
                          "Partial Mode": "Simple",
                          "Parent Relationship": "Outer",
                          "Parallel Aware": false,
                          "Async Capable": false,
                          "Actual Rows": 1882.00,
                          "Actual Loops": 1,
                          "Disabled": false,
                          "Group Key": ["p.product_id", "date(orders.order_date)"],
                          "Filter": "(sum(oi.quantity) >= 1)",
                          "HashAgg Batches": 1,
                          "Peak Memory Usage": 1105,
                          "Disk Usage": 0,
                          "Rows Removed by Filter": 0,
                          "Plans": [
                            {
                              "Node Type": "Hash Join",
                              "Parent Relationship": "Outer",
                              "Parallel Aware": false,
                              "Async Capable": false,
                              "Join Type": "Inner",
                              "Actual Rows": 1918.00,
                              "Actual Loops": 1,
                              "Disabled": false,
                              "Inner Unique": false,
                              "Hash Cond": "(p.category_id = ct.category_id)",
                              "Plans": [
                                {
                                  "Node Type": "Hash Join",
                                  "Parent Relationship": "Outer",
                                  "Parallel Aware": false,
                                  "Async Capable": false,
                                  "Join Type": "Inner",
                                  "Actual Rows": 1918.00,
                                  "Actual Loops": 1,
                                  "Disabled": false,
                                  "Inner Unique": true,
                                  "Hash Cond": "(oi.product_id = p.product_id)",
                                  "Plans": [
                                    {
                                      "Node Type": "Hash Join",
                                      "Parent Relationship": "Outer",
                                      "Parallel Aware": false,
                                      "Async Capable": false,
                                      "Join Type": "Inner",
                                      "Actual Rows": 1918.00,
                                      "Actual Loops": 1,
                                      "Disabled": false,
                                      "Inner Unique": true,
                                      "Hash Cond": "(oi.order_id = orders.order_id)",
                                      "Plans": [
                                        {
                                          "Node Type": "Seq Scan",
                                          "Parent Relationship": "Outer",
                                          "Parallel Aware": false,
                                          "Async Capable": false,
                                          "Relation Name": "order_items",
                                          "Alias": "oi",
                                          "Actual Rows": 6038.00,
                                          "Actual Loops": 1,
                                          "Disabled": false,
                                          "Filter": "(unit_price >= 1000.00)",
                                          "Rows Removed by Filter": 3962
                                        },
                                        {
                                          "Node Type": "Hash",
                                          "Parent Relationship": "Inner",
                                          "Parallel Aware": false,
                                          "Async Capable": false,
                                          "Actual Rows": 323.00,
                                          "Actual Loops": 1,
                                          "Disabled": false,
                                          "Hash Buckets": 1024,
                                          "Original Hash Buckets": 1024,
                                          "Hash Batches": 1,
                                          "Original Hash Batches": 1,
                                          "Peak Memory Usage": 22,
                                          "Plans": [
                                            {
                                              "Node Type": "Seq Scan",
                                              "Parent Relationship": "Outer",
                                              "Parallel Aware": false,
                                              "Async Capable": false,
                                              "Relation Name": "orders",
                                              "Alias": "orders",
                                              "Actual Rows": 323.00,
                                              "Actual Loops": 1,
                                              "Disabled": false,
                                              "Filter": "((status)::text = 'PENDING'::text)",
                                              "Rows Removed by Filter": 677
                                            }
                                          ]
                                        }
                                      ]
                                    },
                                    {
                                      "Node Type": "Hash",
                                      "Parent Relationship": "Inner",
                                      "Parallel Aware": false,
                                      "Async Capable": false,
                                      "Actual Rows": 500.00,
                                      "Actual Loops": 1,
                                      "Disabled": false,
                                      "Hash Buckets": 1024,
                                      "Original Hash Buckets": 1024,
                                      "Hash Batches": 1,
                                      "Original Hash Batches": 1,
                                      "Peak Memory Usage": 34,
                                      "Plans": [
                                        {
                                          "Node Type": "Seq Scan",
                                          "Parent Relationship": "Outer",
                                          "Parallel Aware": false,
                                          "Async Capable": false,
                                          "Relation Name": "products",
                                          "Alias": "p",
                                          "Actual Rows": 500.00,
                                          "Actual Loops": 1,
                                          "Disabled": false
                                        }
                                      ]
                                    }
                                  ]
                                },
                                {
                                  "Node Type": "Hash",
                                  "Parent Relationship": "Inner",
                                  "Parallel Aware": false,
                                  "Async Capable": false,
                                  "Actual Rows": 100.00,
                                  "Actual Loops": 1,
                                  "Disabled": false,
                                  "Hash Buckets": 1024,
                                  "Original Hash Buckets": 1024,
                                  "Hash Batches": 1,
                                  "Original Hash Batches": 1,
                                  "Peak Memory Usage": 12,
                                  "Plans": [
                                    {
                                      "Node Type": "CTE Scan",
                                      "Parent Relationship": "Outer",
                                      "Parallel Aware": false,
                                      "Async Capable": false,
                                      "CTE Name": "category_tree",
                                      "Alias": "ct",
                                      "Actual Rows": 100.00,
                                      "Actual Loops": 1,
                                      "Disabled": false,
                                      "Storage": "Memory",
                                      "Maximum Storage": 21
                                    }
                                  ]
                                }
                              ]
                            }
                          ]
                        }
                      ]
                    }
                  ]
                }
              ]
            }
          ]
        }
      ]
    },
    "Triggers": [
    ]
  }
]

This query is used to calculate statistics and rank sales of high-value products (>1000) by day, executing each step in order of the Bottom-Up data flow:

  • Uses recursion to retrieve all products with category_id = 1 and products belonging to its sub-categories, saving the result in a CTE named category_tree
  • target_orders stores orders with status=PENDING
  • Data Preparation
    • Filters high-priced order details from order_items according to the condition oi.unit_price >= 1000.00, resulting in "Actual Rows": 6038.00
    • Loads table products according to the condition oi.product_id = p.product_id, resulting in "Actual Rows": 500.00
    • Loads CTE category_tree according to the condition p.category_id = ct.category_id, resulting in "Actual Rows": 100.00
  • Uses consecutive Hash Join operations as follows:
    • Joins order_items with orders with condition "Hash Cond": "(oi.order_id = orders.order_id)"
    • Joins the result above with products with condition "Hash Cond": "(oi.product_id = p.product_id)"
    • Joins the result above with category_tree with condition "Hash Cond": "(p.category_id = ct.category_id)"
    • The output consists of 1,918 rows.
  • Groups data into 1,882 rows by product and date, calculating totals with HAVING SUM(oi.quantity) >= 1.
  • Sorting and Window Functions computation
    • Sorting for Window Functions is (PARTITION BY DATE(o.order_date)) and PARTITION BY DATE(o.order_date) ORDER BY SUM(...) DESC
    • Calculates product sales ranking for product_sales_rank via DENSE_RANK() OVER w_rank
    • Calculates daily total revenue for daily_total_revenue via SUM(SUM(oi.quantity * oi.unit_price)) OVER w_daily
  • Sorts via ORDER BY p.product_id, DATE(o.order_date), total_revenue DESC
  • Performs pagination via LIMIT 100 OFFSET 0

Happy coding!

See more articles here.

Comments

Post a Comment

Popular posts from this blog

All Practice Series

Image
Introduction This is a comprehensive page about the technologies I have shared in series format. You can view brief introductions and links to directly access each series you are interested in. In the field of software development, to deploy a product from the initial idea to its release, the standard process typically involves several stages as follows: Database : Designing and implementing the database according to business requirements, storing data during the system's operation. Backend : Handling the main logic of the system, communicating with the database and services. Frontend : Building the interface for users to interact with the system, which could be a desktop, mobile, or web application. This usually includes implementing UI/UX and integrating APIs from the backend. DevOps : Deploying the system for use, which can be done on a server or in the cloud. Testing : Applying testing methods to ensure the product meets the standards for release. Of course, these are just stan...
Read more

Kubernetes Deployment for Zero Downtime

Image
Introduction In Kubernetes (K8s) , a Pod is the smallest resource unit used to run one or more containers during deployment. There are several ways to create a Pod : you can create it directly, use a ReplicationController , or a ReplicaSet . However, the most commonly used resource for managing Pods is the Deployment . When you use a Deployment , it actually creates a ReplicaSet to manage the Pods but comes with many additional benefits that support the deployment process. Some Advantages of Deployment : Ensures Pod Availability : It guarantees that the specified number of Pods are always running according to the configuration, automatically deploying additional Pods if any failures occur. Supports Restart and Undo Deployment : Allows you to easily restart or roll back to previous versions of your Deployment . Zero Downtime Deployment : When updating configurations or scaling Deployments , zero downtime is crucial. This means that new Pods are created while the old Pods are stil...
Read more

Deploying a NodeJS Server on Google Kubernetes Engine

Image
Introduction to GKE Google Kubernetes Engine (GKE) is a managed Kubernetes service provided by Google Cloud Platform , facilitating simple and efficient deployment of Docker images. We only need to provide some configuration for the number of nodes, machine types, and replicas to use. Some Concepts Cluster A Cluster is a collection of Nodes where Kubernetes can deploy applications. A cluster includes at least one Master Node and multiple Worker Nodes . The Master Node is used to manage the Worker Nodes . Node A Node is a server in the Kubernetes Cluster. Nodes can be physical servers or virtual machines. Each Node runs  Kubernetes , which is responsible for communication between the Master Node and Worker Node , as well as managing Pods and containers running on it. Pod A Pod is the smallest deployable unit in Kubernetes . Each Pod contains one or more containers, typically Docker containers. Containers in the same Pod share a network namespace, meaning they have the ...
Read more

Sitemap

Image
A page aggregator designed for easy reference and search, compiling all blog posts for convenient access. Loading all posts...
Read more

React Practice Series

Image
Introduction React is a JavaScript library created by Facebook , often referred to as the most popular frontend framework today. This page aims to gather articles related to ReactJS , covering topics such as theory, features, and commonly used packages in the process of building ReactJS applications. I will update this series with more articles in the future as new ideas for content come up. The articles are arranged in increasing order of difficulty, so if you have time, it's recommended to start from the beginning of the series. This will ensure you grasp the essential knowledge and information needed for the subsequent articles. Here are some key topics in the series that you need to explore to effectively use ReactJS : Fundamental : React Hook, React Reconciliation. State management : redux, mobx, recoil, zustand, xstate, etc. Middleware libraries : redux-thunk, redux-saga, redux-observable, etc. Popular packages : tasnstack query, immer, styled-components, etc. Rendering te...
Read more

Docker Practice Series

Image
Introduction Docker is an open platform for developing, shipping, and running applications. This page is dedicated to compiling articles related to Docker , covering both the theoretical aspects and practical applications of Docker in setting up popular tools essential for software development. I will be updating this series with more articles in the future as new ideas for topics arise. The articles are arranged in increasing order of difficulty, making it easier for you to follow along. If you have the time, I recommend starting from the beginning of the series to ensure that you grasp the necessary knowledge and information needed for the more advanced articles later on. Here are some key topics in the series that you need to explore to effectively use Docker : Basic knowledge Docker commands Docker Compose Building Docker images Performance improvement Integration with CI/CD Once you have a solid understanding of the foundational knowledge, the extended topics (including advanced...
Read more

Helm for beginer - Deploy nginx to Google Kubernetes Engine

Image
Introduction Helm is a package manager for Kubernetes , which simplifies the process of deploying and managing applications on Kubernetes clusters. Helm uses a packaging format called charts , which are collections of files that describe a related set of Kubernetes resources. Key Components of Helm Charts : Helm packages are called charts. A chart is a collection of files that describe a related set of Kubernetes resources. A single chart might be used to deploy something simple, like a memcached pod, or something complex, like a full web app stack with HTTP servers , databases, caches, and so on. Values : Charts can be customized with values, which are configuration settings that specify how the chart should be installed on the cluster. These values can be set in a ` values.yaml ` file or passed on the command line. Releases : When you install a chart, a new release is created. This means that one chart can be installed multiple times into the same cluster, and each can be indep...
Read more

A Handy Guide to Using Dynamic Import in JavaScript

Image
Introduction In JavaScript, when we import a file, the process usually happens synchronously, known as static import. However, as our applications grow, this synchronous loading can lead to slower initial page loads due to larger JavaScript bundles. Moreover, there are times when imports are necessary only under specific circumstances, leading to unnecessary loading times for users who might not even utilize those features. Details Instead of burdening all users with unnecessary imports, dynamic imports come to the rescue. They allow us to load modules or files only when they are needed, thus improving performance and user experience. Dynamic imports are invoked using the import() function and return a promise. When using default exports, the exported data can be accessed through the default field, while other data can be accessed through fields with matching names. Here's how you can use dynamic imports: import ( "ramda" ). then ( module => { const moduleDefaul...
Read more

DevOps Practice Series

Image
Introduction DevOps is a combination of development (Dev) and operations (Ops), aimed at uniting people, processes, and technology to enhance the software development lifecycle. Here are some key aspects of DevOps: Collaboration and Communication: DevOps fosters a culture where development, IT operations, quality engineering, and security teams work together seamlessly. Continuous Integration and Continuous Delivery (CI/CD): These practices automate the integration and delivery of code changes, ensuring faster and more reliable software releases. Infrastructure as Code (IaC): This approach involves managing and provisioning computing infrastructure through machine-readable scripts, rather than physical hardware configuration. Monitoring and Logging: Continuous monitoring and logging help teams to detect issues early and maintain system reliability. Automation: Automating repetitive tasks reduces errors and increases efficiency, allowing teams to focus on more strategic work. By impleme...
Read more

Kubernetes Practice Series

Image
Introduction Kubernetes (often abbreviated as K8s ) is an open-source system designed to automate the deployment, scaling, and management of containerized applications. This page serves as a collection of articles related to Kubernetes (K8s) , including theoretical concepts and practical guides on using Kubernetes to set up essential tools for the software development process. I will continue to update this series with new articles as ideas come to mind, to ensure the series becomes more comprehensive. The articles are arranged in increasing order of difficulty to make it easier for you to follow. If you have time, it's recommended that you start from the beginning of the series to acquire the necessary knowledge and information that will prepare you for the subsequent articles. Key Topics Covered in This Series Basic Knowledge : Fundamental concepts, common commands, etc. Resources : Pod, Deployment, Service, StatefulSet, Ingress, etc. Pod Autoscaler : Horizontal and Vertical sc...
Read more