Event-driven architecture in Nginx - Step-by-Step Execution

Process Flow - Event-driven architecture

Client Request Arrives

↓

Event Loop Receives Event

↓

Check Event Type

↓

HTTP

↓

Process HTTP

↓

Send Response

↓

Wait for Next Event

Nginx waits for events like client requests, processes them based on type, sends responses, and then waits for new events.

Execution Sample

Nginx

worker_processes 1;
events {
    worker_connections 1024;
}
http {
    server {
        listen 8080;
    }
}

This config sets nginx to handle events with one worker and listen for HTTP requests on port 8080.

Process Table

Step	Event	Action	Worker Process State	Response Sent
1	Client connects on port 8080	Event loop accepts connection	Idle -> Processing	No
2	HTTP request received	Parse request and route	Processing	No
3	Request handled by server block	Generate response	Processing	No
4	Response sent to client	Send HTTP response	Processing -> Idle	Yes
5	Wait for next event	Idle state	Idle	No

💡 No more events, worker waits idle for new client requests

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
worker_state	Idle	Processing	Processing	Processing	Idle	Idle
response_sent	No	No	No	No	Yes	Yes

Key Moments - 2 Insights

Why does nginx stay idle after sending a response instead of closing?

Nginx uses an event loop to handle many requests efficiently. After sending a response (see step 4 in execution_table), it returns to idle to wait for new events instead of closing.

How does nginx know which worker process handles the request?

The event loop assigns incoming events to worker processes. In this example, with one worker (execution_sample), that worker handles all events, shown by the worker_state changes in variable_tracker.

Visual Quiz - 3 Questions

Look at the execution_table, what is the worker process state at Step 3?

A Idle

B Waiting

C Processing

D Closed

💡 Hint

Check the 'Worker Process State' column at Step 3 in execution_table

At which step is the HTTP response sent to the client?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'Response Sent' column in execution_table to find when it changes to Yes

If nginx had 2 worker processes, how would the variable_tracker change?

A response_sent would be always No

B worker_state would show states for both workers separately

C worker_state would stay Idle all the time

D No change in variable_tracker

💡 Hint

Multiple workers mean tracking each worker's state separately in variable_tracker

Concept Snapshot

Event-driven architecture in nginx:
- Uses event loop to handle client requests asynchronously
- Worker processes wait for events, process requests, send responses
- Efficiently manages many connections without blocking
- Configured via 'events' and 'worker_processes' directives
- Keeps workers idle when no events, ready for next request

Full Transcript

Event-driven architecture in nginx means it waits for events like client requests using an event loop. When a client connects, nginx accepts the connection and assigns it to a worker process. The worker processes the HTTP request, generates a response, sends it back, and then returns to idle to wait for more events. This allows nginx to handle many requests efficiently without blocking. The configuration sets how many worker processes run and how many connections each can handle. The execution table shows each step from connection to response. Variables track worker state and response status. This model helps nginx serve many clients quickly and reliably.