Skip to main content
AIDevOps
  • Learn
  • Learning Paths
  • Practice
  • Open Source
  • Books
  • Engineering

    AI DevOpsThe full map of building and operating AI servicesLLMOpsLLM deployment Β· evaluation Β· observabilityHands-on ProjectsBuild AI Agent projects

    Knowledge

    DocsTechnical documentationBlogEngineering articlesPloggerDevelopment log feed

    Validate

    Certification3-level skills certification Β· coming soon
AI Models
LlamaTutorial|MistralTutorial|GemmaTutorial|DeepSeekTutorial|QwenTutorial
🧱 Infrastructure
Infrastructure Intro & RoadmapNginxRedis
πŸ€– AI Applied Development
Applied AI Intro & RoadmapHugging FaceLangChainLlamaIndexLLMOps|LangGraphMCPMulti-AgentAgent Evaluation
🧠 AI Core
AI Intro & RoadmapML FundamentalsLLM Fundamentals|Python AIC++|PyTorchTensorFlowJAX
🧠 AI Agent Development
Finance AI AgentLLM API ServerStock Investing AgentAIOps AI AgentEducation AI AgentCoding AI Agent
🌱 Spring Cloud
Spring Intro & RoadmapSpring Cloud GatewaySpring BootJava|Spring AISpring SecuritySpring BatchSpring JPA
🐳 DevOps
DevOps Intro & RoadmapLinuxDockerCI/CD|Kubernetes BasicsK8s AdvancedPrometheusGrafana
☁️ Cloud
Cloud Intro & RoadmapAWSGCPAzureNCPCloudflare
🎨 Frontend
Frontend Intro & RoadmapJavaScriptTypeScript|ReactNext.js|VueNuxt|Electron
πŸ“± Mobile
Mobile Intro & RoadmapKotlinAndroidFlutter
βš™οΈ Backend
Backend Intro & RoadmapPython BasicsFastAPIDjangoFlask|CGoGinNode.js
πŸ’Ύ Database
DB Intro & RoadmapCore SQLOracleMySQLPostgreSQL|MongoDBVector DB
πŸ§ͺ Testing
k6JMeternGrinder
AIDevOps

Engineering AI. From Code to Production.
An engineering learning platform for building and operating AI and AI Agents

Learn

  • All Guides
  • Learning Paths
  • AI Tutorial
  • Practice
  • Books

Resources

  • AI DevOps
  • LLMOps
  • Hands-on Projects
  • Docs
  • Blog
  • Plogger
  • Open Source
  • Certification (coming soon)

Start Here

  • AI Core Roadmap
  • AI Applied Development Roadmap
  • Spring Cloud Roadmap
  • DevOps Roadmap
  • Infrastructure Roadmap

Β 

  • Cloud Roadmap
  • Frontend Roadmap
  • Mobile Roadmap
  • Backend Roadmap
  • Database Roadmap
Β© 2026 AIDevOps. All rights reserved.
Terms of ServicePrivacy PolicySitemaptestforge.kr
  1. Home
  2. Learn
  3. Infrastructure
  4. Infrastructure Intro & Roadmap
The first guide for newcomers to web infrastructure

🧭 Infrastructure Intro & Roadmap Complete Guide

Visitors

A starting point for anyone learning web service infrastructure for the first time. It covers the roles of DNS, load balancers, reverse proxies, and caches on the path a user request takes to reach the server, how to scale a system as traffic grows, where Nginx and Redis sit in the architecture, and a step-by-step learning roadmap.

  • Beginner
  • Updated Oct 1, 2026
  • ~7 min read
  • 11 sections
  • 1 code examples
🧭
The big picture of web infrastructureUnderstand the request flowThe roles of Nginx and RedisScaling strategy basicsInfrastructure learning order

Related frameworks & environments

🌐Nginxβ†’πŸ”΄Redisβ†’πŸ§Linuxβ†’πŸ³Dockerβ†’

Contents

0 / 14
  1. How to use this guide
  2. Architecture diagrams
  3. What infrastructure is
  4. The path a request takes
  5. Reverse proxies and load balancers
  6. Your first Nginx config
  7. Caching strategy
  8. Scaling strategy
  9. Before you start
  10. Step-by-step roadmap
  11. 6-week study plan
  12. Common mistakes
  13. Key terms
  14. Frequently asked questions
Contents 14 sections
  1. How to use this guide
  2. Architecture diagrams
  3. What infrastructure is
  4. The path a request takes
  5. Reverse proxies and load balancers
  6. Your first Nginx config
  7. Caching strategy
  8. Scaling strategy
  9. Before you start
  10. Step-by-step roadmap
  11. 6-week study plan
  12. Common mistakes
  13. Key terms
  14. Frequently asked questions

How to use this guide

How to read it

Understanding Infrastructure Intro & Roadmap as a real-world workflow

A starting point for anyone learning web service infrastructure for the first time. It covers the roles of DNS, load balancers, reverse proxies, and caches on the path a user request takes to reach the server, how to scale a system as traffic grows, where Nginx and Redis sit in the architecture, and a step-by-step learning roadmap. Rather than listing concepts, this guide is organized so you can follow the content in the order you have to make decisions on a real project.

Key perspective

Infrastructure / operations

Rather than memorizing install commands, understand the order in which traffic, runtime, observability, and incident response connect.

The big picture of web infrastructureUnderstand the request flowThe roles of Nginx and RedisScaling strategy basicsInfrastructure learning order

Architecture diagrams

To make what you read stick, it helps to capture the flow as a picture first. The two diagrams below are reference maps you can keep coming back to while learning Infrastructure Intro & Roadmap.

Learning flow

Rendering diagram…

Architecture view

Rendering diagram…

What infrastructure is

When you first open Infrastructure Intro & Roadmap, the big picture matters more than individual commands. This section starts with the problems the concepts ahead were created to solve.

Infrastructure is everything that supports an application so that it runs, connects to users, and responds quickly and reliably. That includes servers, networks, load balancers, caches, storage, and certificates.

However good the application code is, weak infrastructure means the service stops when traffic surges. Well-designed infrastructure, on the other hand, lets the same code serve tens of times more users. This category covers the two pieces that show up in almost every web service β€” Nginx (the gateway for traffic) and Redis (the key to speed).
Infrastructure elementRoleTypical technologies
DNSTranslates a domain name β†’ IP addressRoute 53, Cloudflare DNS
CDNServes static files from close to the userCloudflare, CloudFront
Load balancer / reverse proxyDistributes requests across servers, handles TLSNginx, ALB
Application serverRuns the business logicFastAPI, Spring Boot, Node.js
CacheKeeps frequently used data in memoryRedis
DatabaseDurable storagePostgreSQL, MySQL

The path a request takes

The path a request takes is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

When a user opens https://shop.example.com/products/42, the request passes through several layers. Each layer either handles it quickly and returns or passes it on to the next layer. The earlier the layer that handles it, the faster and cheaper it is.
OrderLayerWhen the request can end here
1Browser cacheImages and CSS already downloaded are not requested again
2DNS-
3CDN (edge)Static files and cacheable pages are answered immediately at the edge
4Nginx (reverse proxy)Serves static files directly, blocks requests over the rate limit
5Application server-
6Redis (cache)On a cache hit, answers without a DB query
7DatabaseThe final store β€” the slowest and most expensive layer

Tip

The basic principle of performance work is "end the request at the earliest layer possible". The fewer requests that reach the DB, the faster and cheaper the system becomes.

Reverse proxies and load balancers: where Nginx sits

Reverse proxies and load balancers: where Nginx sits is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

A reverse proxy is a server that stands between users and the application servers, receiving requests on their behalf and forwarding them. Users cannot tell how many servers are behind it or what language they are written in. Nginx is the most widely used reverse proxy and web server.
What Nginx doesDescription
TLS terminationHandles HTTPS encryption and decryption, taking the load off the app servers
Load balancingDistributes requests across several app servers (round robin, least connections, and so on)
Static file servingAnswers images, JS, and CSS directly without going through the app server
Rate limitingLimits requests per second per IP to soften excessive traffic and attacks
Path routingSends /api to the backend and / to the frontend
Compression Β· cachinggzip compression, response caching

Your first Nginx config: HTTPS + load balancing

Here you look at Your first Nginx config: HTTPS + load balancing alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

The configuration below distributes HTTPS requests across two app servers, while Nginx answers static files itself. Most real-world Nginx configurations are variations on this structure.
/etc/nginx/conf.d/app.confNGINX
upstream app_servers {
    least_conn;                       # to the server with the fewest connections
    server 10.0.0.11:8000;
    server 10.0.0.12:8000;
}

server {
    listen 443 ssl;
    server_name shop.example.com;

    ssl_certificate     /etc/letsencrypt/live/shop.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/shop.example.com/privkey.pem;

    location /static/ {               # Nginx serves static files itself
        root /var/www;
        expires 7d;
    }

    location / {                      # everything else goes to the app servers
        proxy_pass http://app_servers;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Tip

After changing the configuration, always check the syntax with nginx -t and apply it without downtime using nginx -s reload. restart drops existing connections.

Caching strategy: why Redis is fast

Caching strategy: why Redis is fast is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Redis is a key-value store that keeps data in memory. It is tens to hundreds of times faster than a disk-based DB, which makes it a good home for data that is read often but changes rarely. Memory is expensive and volatile, though, so the basic rule is "the original lives in the DB, the copy lives in Redis".
Usage patternExampleKey point
Read cache (Cache-Aside)Product detail, popular postsOn a miss, read the DB and store the result; set a TTL
Session storeLogin sessionsSeveral servers share the sessions
Rate limit counterLimit API calls per secondINCR + EXPIRE as atomic operations
LeaderboardReal-time rankingsSorted Set
Distributed lockPrevent duplicate payments and duplicate issuanceSET NX + an expiry
Messages Β· streamsSimple job queues, eventsList, Pub/Sub, Stream

Tip

The hardest problem in caching is "when to delete (invalidation)". Start with a short TTL, and combine it with deleting the key when the data changes.

Scaling strategy: when traffic grows 10x

Scaling strategy: when traffic grows 10x is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

The precondition for horizontal scaling is that the application servers hold no state. Sessions or uploaded files kept in server memory or on its disk vanish when a request goes to a different server. That is why moving sessions to Redis and files to object storage is the first step in scaling.
StrategyHowProsLimits
Vertical scaling (scale-up)Raise the server specNo code change, the easiestCost climbs fast, there is a ceiling, single point of failure
Horizontal scaling (scale-out)Add servers + a load balancerUnlimited in theory, fault isolationThe app has to be stateless
CachingFewer DB requests through Redis and a CDNA big effect for little costData freshness has to be managed
Read replicasSpread DB reads across replicasEffective for read-heavy servicesReplication lag
Async processingMove long-running work onto a queueFaster responsesResults have to be tracked

Before you start

Before you start is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Nginx and Redis start in seconds with Docker, so a practice environment is very easy to set up.
AreaWhatHow much
LinuxInstalling packages, managing services (systemctl), reading logsLinux basics
NetworkingIP, ports, DNS, HTTP headers, TLS certificatesUnderstand the concepts
DockerRun Nginx and Redis as containersDocker basics
One web appA simple API server to put behind the proxyAbout step 1 of the Backend roadmap

Step-by-step roadmap

Step-by-step roadmap is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

StepGoalWhat to learnGuidesDone check
0. BasicsServers and networksLinux commands, ports, DNS, HTTP, TLSLinuxAnalyze request and response headers with curl
1. Web serverExpose a service with NginxStatic files, server/location blocks, logsNginxDeploy a static site
2. Reverse proxyThe front end of the app serversproxy_pass, header forwarding, HTTPS (Let's Encrypt)NginxServe an API over HTTPS
3. Load balancingSpread across several serversupstream, balancing algorithms, health checks, rate limitingNginxBalance across 2 app servers + test with 1 down
4. CacheIntroduce RedisData structures, TTL, Cache-Aside, session storageRedisCompare response time before and after caching
5. Advanced RedisConcurrency and stabilityDistributed locks, Rate Limit, persistence (RDB/AOF), replicationRedisPrevent duplicate first-come-first-served coupon issuance
6. VerificationMeasure the limitsLoad testing, bottleneck analysisk6A report on the throughput (RPS) limit
7. Next stepsExtend into operations automationContainer orchestration, cloudDevOps roadmap, Cloud roadmap-

6-week study plan: 1 hour a day

6-week study plan: 1 hour a day is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Do not skip the load test in the last week. Seeing in numbers how much caching and load balancing really help is what builds an instinct for infrastructure.
WeekTopicDeliverable
Week 1Networking, HTTP, TLS basicsNotes analyzing the request flow with curl and developer tools
Week 2Nginx web server + reverse proxyAn HTTPS API service
Week 3Load balancing + rate limitingDocker Compose: Nginx + 2 app servers
Week 4Redis basics + cachingA product lookup cache + performance comparison
Week 5Redis sessions, locks, Rate LimitShared sessions + first-come-first-served issuance
Week 6Load testing + wrap-upk6 test results + an architecture diagram

Common mistakes of infrastructure beginners

Common mistakes of infrastructure beginners is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Always remember that Redis processes commands on a single thread, so one long-running command can block every request.
MistakeProblemDo this instead
Missing X-Forwarded-* headers behind the proxyThe app sees every request as coming from the proxy IP over HTTPPass the original information with proxy_set_header
Restarting after a config change without a syntax checkThe whole service goes downnginx -t, then reload
Using Redis as the system of recordData lost on restart or failureThe original lives in the DB; Redis is a cache and a helper
Cache keys with no TTLMemory exhaustion, stale dataAn expiry on every cache key
Using the KEYS * commandAll of Redis stalls with a large number of keysUse SCAN
Exposing Redis externally without authenticationData theft, server takeoverInternal network only + password/ACL

Key terms

Key terms is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

TermOne-line explanation
Reverse proxyA server in front of your servers that receives requests on their behalf and forwards them
UpstreamThe group of backend servers Nginx forwards requests to
TLS terminationA setup where the proxy decrypts HTTPS and forwards plain HTTP internally
TTLHow long cached data stays valid
Cache hit rateThe share of requests answered straight from the cache
Cache stampedeCaches expiring at the same moment so that requests flood the DB all at once
StatelessThe server stores no state between requests, so any server can handle any request
Health checkA periodic request that checks whether a server is healthy
Rate LimitingLimiting the number of requests allowed in a period of time
CDNA network that caches content on edge servers around the world and serves it from nearby

Tip

The next step is the Nginx guide. Configure it yourself, from static file serving through to a reverse proxy.

Infrastructure Intro & Roadmap: frequently asked questions

Where should I start studying infrastructure?

Follow the path a request takes from the user to the server: DNS and HTTP, the reverse proxy (Nginx), the application server, the cache (Redis), and the database. Once you understand what problem each component exists to solve, moving on to Docker and the cloud connects naturally.

What is the difference between a reverse proxy and a load balancer?

A reverse proxy receives client requests on behalf of the servers behind it and forwards them, and a load balancer spreads requests across several servers. In practice one product often does both. Nginx is a reverse proxy that can also load balance.

When should I introduce a cache?

When the same data is read repeatedly, is expensive to produce, and showing a slightly stale value is acceptable. A cache brings the problems of values drifting from the source and of managing expiry, so first check whether better queries and indexes solve it.

Next guide β†’Nginx