2.2. IP Addresses
Table of Contents
Why IP Addresses Exist
When two computers talk over the internet, they must know where to send data. An IP address is the basic way to identify a device on a network, similar to a phone number or a street address for a house.
Every time you:
- open a website
- call an API from your backend
- connect to a database on another machine
your computer sends data to an IP address.
Without IP addresses, routers and servers would not know where any packet of data should go. For backend developers, understanding IPs is essential for configuring servers, debugging connectivity problems, and securing applications.
Important: An IP address uniquely identifies a device or interface on a network so that data can be routed to and from it.
IPv4 Basics
The most common IP version you will see is IPv4. It uses 32 bits to represent an address.
Human-readable IPv4 format
IPv4 addresses are usually written as four numbers separated by dots, for example:
8.8.8.8192.168.1.10172.16.0.5
Each of the four numbers is called an octet and can range from 0 to 255.
Under the hood, each octet is 8 bits, so an IPv4 address is:
$$4 \text{ octets} \times 8 \text{ bits per octet} = 32 \text{ bits}$$
Example:
- IPv4:
192.168.1.10 - In binary:
- 192 →
11000000 - 168 →
10101000 - 1 →
00000001 - 10 →
00001010
So the full binary representation is:
11000000 10101000 00000001 00001010
You will rarely need to work directly with the binary representation, but it helps to understand that IPs are just numbers.
Total number of IPv4 addresses
With 32 bits, the total number of unique IPv4 addresses is:
$$2^{32} = 4,294,967,296$$
So there are about 4.29 billion possible IPv4 addresses.
Because the internet has grown a lot, 4.29 billion is not enough for all devices worldwide, which is one reason why IPv6 exists and why we have techniques like private IP ranges and NAT (more on these later).
Rule: An IPv4 address is a 32-bit number, usually written as four decimal numbers from 0 to 255, separated by dots.
IPv6 Basics
IPv6 is the newer version of the Internet Protocol. It was created to solve the address exhaustion problem of IPv4 and to simplify some network operations.
IPv6 format
IPv6 uses 128 bits, which provides a huge address space.
An IPv6 address looks like this:
2001:0db8:85a3:0000:0000:8a2e:0370:7334
It is written as eight groups (hextets) of four hexadecimal digits, separated by colons.
For example:
- Group 1:
2001 - Group 2:
0db8 - Group 3:
85a3 - Group 4:
0000 - Group 5:
0000 - Group 6:
8a2e - Group 7:
0370 - Group 8:
7334
Each hexadecimal digit represents 4 bits, so:
- each group has 4 hex digits = 16 bits
- 8 groups × 16 bits = 128 bits in total
The total number of IPv6 addresses is:
$$2^{128} \approx 3.4 \times 10^{38}$$
This is an astronomically large number. For practical purposes, we will never run out.
Shortening IPv6 addresses
IPv6 addresses can be long, so there are rules to shorten them.
- Leading zeros inside a group can be removed:
0db8→db80370→370- One sequence of consecutive groups of
0000can be replaced by::(double colon), but only once per address.
Example:
Full form:
2001:0db8:0000:0000:0000:ff00:0042:8329
Shortened step by step:
- remove leading zeros:
2001:db8:0:0:0:ff00:42:8329- compress consecutive zero groups:
2001:db8::ff00:42:8329
Both represent the same IPv6 address.
Rule: An IPv6 address is a 128-bit number, written as eight groups of 4 hexadecimal digits, separated by colons. You can remove leading zeros and compress one sequence of zero groups using ::.
Public vs Private IP Addresses
Not every IP address is reachable from the entire internet. Some address ranges are reserved for private networks, such as your home Wi-Fi or a company LAN.
Public IP addresses
A public IP address is globally unique on the internet and can be routed across the public network.
If a server should be reachable from anywhere (for example an API server), it needs a public IP address, or it must be reachable through something that has one (like a load balancer or NAT gateway).
You can usually see your current public IP by visiting a site like https://ifconfig.me or https://ipinfo.io.
Private IP addresses (IPv4)
Private IPv4 address ranges are defined so that organizations can have many devices internally without needing a public address for each.
The commonly used private IPv4 ranges are:
| Range | CIDR | Example addresses |
|---|---|---|
10.0.0.0 to 10.255.255.255 | 10.0.0.0/8 | 10.0.0.1, 10.10.5.2 |
172.16.0.0 to 172.31.255.255 | 172.16.0.0/12 | 172.16.0.3, 172.31.200.5 |
192.168.0.0 to 192.168.255.255 | 192.168.0.0/16 | 192.168.0.1, 192.168.1.10 |
You will see 192.168.x.x very often in home networks. For example, your router might be at 192.168.0.1 and your laptop at 192.168.0.23.
These private addresses are not routable over the public internet. They are only meaningful inside their own network.
NAT and private IPs
If many devices use private IP addresses, how do they access the public internet?
Usually through Network Address Translation (NAT), which is typically implemented in your router. In simple terms:
- inside the local network, devices use private IP addresses like
192.168.0.10 - the router has a public IP address like
203.0.113.5 - when your device connects to the internet, the router replaces the source IP (
192.168.0.10) with its own public IP (203.0.113.5), and keeps track of which internal connection belongs to which internal device
As a backend developer, NAT affects things like:
- servers behind NAT that need port forwarding to be accessible from outside
- services running in containers or virtual machines with private IPs
- understanding why your server may see all requests coming from the same IP (a reverse proxy or load balancer doing NAT in front)
Private IPv6
IPv6 has its own way of defining addresses that are meant to be local only, such as:
fc00::/7(Unique Local Addresses)fe80::/10(Link-Local Addresses, used inside a single network segment)
In practice, as a beginner backend developer you will more often deal with IPv4 private ranges, but IPv6 is increasingly common on modern systems and cloud providers.
Rule:
Public IPs are globally routable on the internet.
Private IPs are used only inside local networks and are not directly reachable from the public internet.
Static vs Dynamic IP Addresses
IP addresses can be assigned in two main ways: statically or dynamically. This applies to both public and private IPs.
Static IP addresses
A static IP address is fixed and does not change over time, unless manually reconfigured.
Examples where static IPs are useful:
- a production API server that must always be reachable at the same IP (or more commonly, behind a DNS name that points to that IP)
- a database server inside a private network that other servers need to connect to
- VPN servers
If you hard-code an IP in a configuration file, that address must be static, otherwise things will break when the IP changes.
Dynamic IP addresses
A dynamic IP address is assigned automatically, usually by a DHCP server.
Common examples:
- your laptop gets a dynamic private IP from your home router, such as
192.168.0.15 - your home internet provider often gives your router a dynamic public IP that may change daily or when the modem restarts
- cloud providers often assign dynamic private IPs to new virtual machines by default
Dynamic assignment makes network management easier, because you do not have to configure each device manually.
As a backend developer you typically care about static IPs for servers and services that other systems must reliably connect to. For local development, dynamic IPs are normally fine.
Special IP Addresses You Will See Often
There are several special IP addresses and ranges that behave differently. Knowing them helps when reading network configurations and logs.
The loopback address
The loopback address refers to the local machine itself.
- IPv4 loopback:
127.0.0.1 - IPv6 loopback:
::1
When you connect to 127.0.0.1, the traffic never leaves your machine. It is used for:
- local development servers
- internal services on the same machine
- testing network applications without any real network
For example, you might run a local FastAPI server on:
http://127.0.0.1:8000
This means:
- only your own machine can reach that server
- no one else on the network can access it using that IP
If you bind a server to 127.0.0.1, it listens only on the loopback interface. If you bind it to 0.0.0.0, it listens on all network interfaces.
The "any" address
The "any" address is a special one used by servers when binding to all interfaces.
- IPv4 any:
0.0.0.0 - IPv6 any:
::
You will often see configurations like:
- a web server listening on
0.0.0.0:8000
It means:
- accept connections from any IP address, on any local interface, on port 8000
In browser URLs, you do not use 0.0.0.0. It is mainly for server binding and routing, not for clients to connect to.
Broadcast and network addresses (IPv4)
In IPv4 networks, some addresses are reserved for special functions, such as:
- the network address, usually the first address in a subnet
- the broadcast address, usually the last address in a subnet
For example, if you have a subnet like 192.168.1.0/24:
- network address:
192.168.1.0 - broadcast address:
192.168.1.255 - usable host addresses:
192.168.1.1to192.168.1.254
As a backend developer, you rarely need to deal with broadcast directly, but you may see such addresses in network diagrams or logs.
Documentation and example ranges
Some IP ranges are reserved for documentation and examples. They are not used on the public internet, so they are safe to show in tutorials.
For IPv4, example ranges include:
192.0.2.0/24198.51.100.0/24203.0.113.0/24
You will see addresses like 203.0.113.5 in documentation.
For IPv6, examples use 2001:db8::/32.
IP Addresses and Subnets
IP addresses are often written with something called CIDR notation, such as 192.168.1.10/24 or 10.0.0.5/16.
This combines:
- the IP address
- the subnet prefix length (how many bits are for the network part)
Network part vs host part
In IPv4, a 32-bit address is divided into:
- network part (identifies the network)
- host part (identifies a specific device on that network)
In CIDR notation A.B.C.D/N:
Nis the number of bits used for the network part- the remaining
32 - Nbits are for hosts
For example, 192.168.1.10/24:
- network prefix length: 24 bits
- host bits:
32 - 24 = 8bits - network range:
192.168.1.0to192.168.1.255
The network address is 192.168.1.0, broadcast is 192.168.1.255, and the addresses between are usable for devices.
You will learn more about subnets and CIDR when dealing with cloud networking, firewalls, and security groups, but you should already be comfortable reading the notation.
Rule: In 192.168.1.10/24, /24 means the first 24 bits are the network part. The rest identify hosts within that network.
Why subnets matter for backend developers
Subnets are important because they define:
- which machines are in the same local network
- which traffic goes through gateways or routers
- which IPs can be allowed or denied in firewall rules
Examples:
- Allow only
10.0.0.0/24to access the database server. - Place application servers in
10.0.1.0/24and database servers in10.0.2.0/24.
When configuring cloud security groups or network ACLs, you will frequently see CIDR ranges like these.
IP Addresses in Backend Development Practice
To connect theory with what you will actually do, here are concrete situations where IP addresses matter in backend work.
Binding servers to an IP
When you start a backend server, you often choose which IP to bind to.
Examples:
- bind to
127.0.0.1to allow only local access (development) - bind to
0.0.0.0to accept connections from any network interface (useful inside containers or when the server is behind a reverse proxy)
For instance, with Uvicorn (a common Python ASGI server):
uvicorn app:app --host 127.0.0.1 --port 8000
means only the local machine can reach it.uvicorn app:app --host 0.0.0.0 --port 8000
means it listens on all interfaces and can be reached from outside, depending on firewalls and networking.
Understanding the difference helps you avoid two common issues:
- You cannot reach your development server from your phone on the same Wi-Fi because it is bound only to
127.0.0.1. - You accidentally expose a development server publicly by binding to
0.0.0.0on a machine with a public IP and no firewall.
Whitelisting and security rules
Many services allow traffic only from specific IP addresses or ranges. For example:
- a managed database service that you configure to accept connections from
203.0.113.5(your server’s public IP) or from10.0.0.0/16(your VPC) - a company firewall that allows SSH only from your office IP range
In these cases you must know:
- what your server’s public IP is
- what CIDR ranges you need to allow
Misconfiguring these can lead to being unable to connect to your own database or accidentally exposing it to the entire internet.
Logs and client IPs
Web server logs usually contain client IP addresses. For example, an Nginx access log line might start with:
203.0.113.42 - - [time] "GET /api/tasks HTTP/1.1" 200 ...
If your application is behind a reverse proxy or load balancer, the IP you see in the application might be that proxy IP, not the original client. In such setups, the real client IP is typically passed in an HTTP header like X-Forwarded-For, which you will handle in later chapters.
From the perspective of this chapter, you should be able to:
- recognize which part of the log line is the client IP
- understand that it might be public or private
- distinguish internal server IPs (for example
10.x.x.x) from external client IPs
Connecting to external APIs and services
When your backend calls an external API, packets go from one IP to another. If the external service restricts by IP (for example, "allow only calls from 198.51.100.12"), and your server’s public IP changes, those calls will start failing.
This is one of the reasons why production servers and outbound gateways are often given static public IPs.
Summary
In this chapter you have learned:
- IPv4 basics: 32-bit addresses, usually written as four numbers separated by dots, like
192.168.1.10. - IPv6 basics: 128-bit addresses, written in hexadecimal groups, like
2001:db8::1. - Public vs private IPs: public IPs are globally routable, private IPs are only valid in local networks.
- Static vs dynamic IPs: static do not change, dynamic are assigned automatically and may change over time.
- Special addresses: loopback (
127.0.0.1,::1), any (0.0.0.0,::), and documentation ranges. - Subnets and CIDR: notations like
192.168.1.0/24define network ranges and are used heavily in firewall and cloud networking.
These concepts are the foundation for understanding DNS, ports, and how requests actually find your backend servers over the network.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to Backend Development
- ☰ 1.1. What Is Backend Development?
- ☰ 1.2. Frontend vs Backend
- ☰ 1.3. How Web Applications Work
- ☰ 1.4. Client-Server Architecture
- ☰ 1.5. Request-Response Cycle
- ☰ 1.6. Static vs Dynamic Websites
- ☰ 1.7. Backend Developer Responsibilities
- ☰ 1.8. Backend Development Roadmap
-
- ☰ 2. How the Web Works
- ☰ 2.1. The Internet and the Web
- ☰ 2.2. IP Addresses
- ☰ 2.3. Domain Names
- ☰ 2.4. DNS
- ☰ 2.5. Ports
- ☰ 2.6. TCP/IP Basics
- ☰ 2.7. HTTP and HTTPS
- ☰ 2.8. HTTP Requests
- ☰ 2.9. HTTP Responses
- ☰ 2.10. HTTP Methods
- ☰ 2.11. HTTP Status Codes
- ☰ 2.12. HTTP Headers
- ☰ 2.13. Cookies
- ☰ 2.14. Sessions
- ☰ 2.15. What Happens When You Enter a URL?
-
- ☰ 3. Development Environment
- ☰ 3.1. Choosing an Operating System
- ☰ 3.2. Linux Basics for Backend Developers
- ☰ 3.3. Command Line Basics
- ☰ 3.4. Environment Variables
- ☰ 3.5. Installing Development Tools
- ☰ 3.6. Code Editors and IDEs
- ☰ 3.7. Git
- ☰ 3.8. GitHub and GitLab
- ☰ 3.9. Creating Your First Repository
- ☰ 3.10. Branches and Commits
- ☰ 3.11. Basic Git Workflow
-
- ☰ 4. Programming Fundamentals
- ☰ 4.1. Variables and Data Types
- ☰ 4.2. Operators
- ☰ 4.3. Conditions
- ☰ 4.4. Loops
- ☰ 4.5. Functions
- ☰ 4.6. Data Structures
- ☰ 4.7. Error Handling
- ☰ 4.8. Modules and Packages
- ☰ 4.9. File Handling
- ☰ 4.10. Object-Oriented Programming
- ☰ 4.11. Classes and Objects
- ☰ 4.12. Inheritance and Composition
- ☰ 4.13. Clean Code Principles
-
- ☰ 5. Python for Backend Development
- ☰ 5.1. Introduction to Python
- ☰ 5.2. Installing Python
- ☰ 5.3. Virtual Environments
- ☰ 5.4. pip and Package Management
- ☰ 5.5. Python Project Structure
- ☰ 5.6. Functions and Type Hints
- ☰ 5.7. Classes and Dataclasses
- ☰ 5.8. Exceptions
- ☰ 5.9. Working with Files
- ☰ 5.9.1. File Downloads
- ☰ 5.9.2. File Validation
- ☰ 5.9.3. Image Uploads
- ☰ 5.9.4. Local File Storage
- ☰ 5.9.5. Object Storage
- ☰ 5.9.6. S3-Compatible Storage
- ☰ 5.9.7. Presigned URLs
- ☰ 5.9.8. Secure File Handling
-
- ☰ 5.10. JSON
- ☰ 5.11. Date and Time
- ☰ 5.12. Logging
- ☰ 5.13. Configuration
- ☰ 5.14. Environment Variables
- ☰ 5.15. Async Programming
- ☰ 5.16. Python Backend Best Practices
-
- ☰ 6. Introduction to Web Backends
- ☰ 6.1. Building a Simple Web Server
- ☰ 6.2. Routing
- ☰ 6.3. URL Parameters
- ☰ 6.4. Query Parameters
- ☰ 6.5. Request Bodies
- ☰ 6.6. Form Data
- ☰ 6.7. JSON Requests
- ☰ 6.8. Returning Responses
- ☰ 6.9. Templates
- ☰ 6.10. Static Files
- ☰ 6.11. Middleware
- ☰ 6.12. Application Configuration
-
- ☰ 7. REST APIs
- ☰ 7.1. What Is an API?
- ☰ 7.2. What Is REST?
- ☰ 7.3. Resources and Endpoints
- ☰ 7.4. RESTful URL Design
- ☰ 7.5. HTTP Methods in REST
- ☰ 7.6. GET Requests
- ☰ 7.7. POST Requests
- ☰ 7.8. PUT Requests
- ☰ 7.9. PATCH Requests
- ☰ 7.10. DELETE Requests
- ☰ 7.11. Request Validation
- ☰ 7.12. Response Models
- ☰ 7.13. HTTP Status Codes
- ☰ 7.14. Error Responses
- ☰ 7.15. Pagination
- ☰ 7.16. Filtering
- ☰ 7.17. Sorting
- ☰ 7.18. Searching
- ☰ 7.19. API Versioning
- ☰ 7.20. API Documentation
- ☰ 7.21. OpenAPI and Swagger
-
- ☰ 8. FastAPI
- ☰ 8.1. Introduction to FastAPI
- ☰ 8.2. Routes and Path Operations
- ☰ 8.3. Path Parameters
- ☰ 8.4. Pydantic Models
- ☰ 8.5. Data Validation
- ☰ 8.6. Dependency Injection
- ☰ 8.7. Exception Handling
- ☰ 8.8. Background Tasks
- ☰ 8.9. File Uploads
- ☰ 8.10. Async Endpoints
- ☰ 8.11. FastAPI Project Structure
- ☰ 8.12. Building a Complete REST API
-
- ☰ 9. Databases
- ☰ 9.1. Introduction to Databases
- ☰ 9.2. Relational vs NoSQL Databases
- ☰ 9.3. Tables, Rows, and Columns
- ☰ 9.4. Primary Keys
- ☰ 9.5. Foreign Keys
- ☰ 9.6. Relationships
- ☰ 9.7. One-to-One Relationships
- ☰ 9.8. One-to-Many Relationships
- ☰ 9.9. Many-to-Many Relationships
- ☰ 9.10. Database Schema Design
- ☰ 9.11. Normalization
- ☰ 9.12. Indexes
- ☰ 9.13. Transactions
- ☰ 9.14. ACID Properties
-
- ☰ 10. SQL
- ☰ 10.1. Introduction to SQL
- ☰ 10.2. CREATE
- ☰ 10.3. INSERT
- ☰ 10.4. SELECT
- ☰ 10.5. UPDATE
- ☰ 10.6. DELETE
- ☰ 10.7. WHERE
- ☰ 10.8. ORDER BY
- ☰ 10.9. GROUP BY
- ☰ 10.10. Aggregate Functions
- ☰ 10.11. JOINs
- ☰ 10.12. Subqueries
- ☰ 10.13. Constraints
- ☰ 10.14. Indexes
- ☰ 10.15. Transactions
- ☰ 10.16. Common Table Expressions
- ☰ 10.17. SQL Performance Basics
-
- ☰ 11. PostgreSQL
- ☰ 11.1. Introduction to PostgreSQL
- ☰ 11.2. Installing PostgreSQL
- ☰ 11.3. Creating Databases
- ☰ 11.4. Users and Roles
- ☰ 11.5. Permissions
- ☰ 11.6. PostgreSQL Data Types
- ☰ 11.7. Constraints
- ☰ 11.8. Indexes
- ☰ 11.9. Transactions
- ☰ 11.10. JSON Data
- ☰ 11.11. Backup and Restore
- ☰ 11.12. PostgreSQL Performance Basics
-
- ☰ 12. ORM and Database Integration
- ☰ 12.1. What Is an ORM?
- ☰ 12.2. SQLAlchemy
- ☰ 12.3. Models
- ☰ 12.4. Database Sessions
- ☰ 12.5. Creating Records
- ☰ 12.6. Reading Records
- ☰ 12.7. Updating Records
- ☰ 12.8. Deleting Records
- ☰ 12.9. Relationships
- ☰ 12.10. Queries
- ☰ 12.11. Transactions
- ☰ 12.12. Connection Pooling
- ☰ 12.13. Database Migrations
- ☰ 12.14. Alembic
- ☰ 12.15. Repository Pattern
-
- ☰ 13. Authentication
- ☰ 13.1. Authentication vs Authorization
- ☰ 13.2. Password Storage
- ☰ 13.3. Password Hashing
- ☰ 13.4. Registration
- ☰ 13.5. Login
- ☰ 13.6. Tokens
- ☰ 13.7. JSON Web Tokens
- ☰ 13.8. Access Tokens
- ☰ 13.9. Refresh Tokens
- ☰ 13.10. OAuth 2.0
- ☰ 13.11. OpenID Connect
- ☰ 13.12. Social Login
- ☰ 13.13. Logout
- ☰ 13.14. Password Reset
- ☰ 13.15. Email Verification
- ☰ 13.16. Multi-Factor Authentication
-
- ☰ 14. Authorization
- ☰ 14.1. Users and Permissions
- ☰ 14.2. Role-Based Access Control
- ☰ 14.3. Permission-Based Access Control
- ☰ 14.4. Protecting API Endpoints
- ☰ 14.5. Admin Permissions
- ☰ 14.6. Resource Ownership
- ☰ 14.7. Authorization Best Practices
-
- ☰ 15. Backend Security
- ☰ 15.1. Introduction to Web Security
- ☰ 15.2. HTTPS and TLS
- ☰ 15.3. SQL Injection
- ☰ 15.4. Cross-Site Scripting
- ☰ 15.5. Cross-Site Request Forgery
- ☰ 15.6. CORS
- ☰ 15.7. Authentication Attacks
- ☰ 15.8. Brute-Force Protection
- ☰ 15.9. Rate Limiting
- ☰ 15.10. Input Validation
- ☰ 15.11. Secure Password Storage
- ☰ 15.12. Secrets Management
- ☰ 15.13. Secure Cookies
- ☰ 15.14. Security Headers
- ☰ 15.15. File Upload Security
- ☰ 15.16. Dependency Vulnerabilities
- ☰ 15.17. OWASP Top 10
-
- ☰ 16. Caching
- ☰ 16.1. Why Caching Matters
- ☰ 16.2. Application Caching
- ☰ 16.3. Redis
- ☰ 16.3.1. Introduction to Redis
- ☰ 16.3.2. Installing Redis
- ☰ 16.3.3. Keys and Values
- ☰ 16.3.4. Expiration
- ☰ 16.3.5. Distributed Locks
-
- ☰ 16.4. Cache Keys
- ☰ 16.5. Cache Invalidation
- ☰ 16.6. Caching Database Queries
- ☰ 16.7. Distributed Caching
-
- ☰ 17. Background Processing
- ☰ 17.1. Synchronous vs Asynchronous Tasks
- ☰ 17.2. Background Jobs
- ☰ 17.3. Message Queues
- ☰ 17.4. Celery
- ☰ 17.5. Redis as a Message Broker
- ☰ 17.6. Scheduled Tasks
- ☰ 17.7. Retry Strategies
- ☰ 17.8. Handling Failed Jobs
- ☰ 17.9. Email Jobs
- ☰ 17.10. Long-Running Tasks
-
- ☰ 18. Email
- ☰ 18.1. How Email Works
- ☰ 18.2. SMTP
- ☰ 18.3. Sending Emails
- ☰ 18.4. HTML Emails
- ☰ 18.5. Transactional Emails
- ☰ 18.6. Password Reset Emails
- ☰ 18.7. Background Email Delivery
- ☰ 18.8. Email Delivery Best Practices
-
- ☰ 19. Testing
- ☰ 19.1. Why Backend Testing Matters
- ☰ 19.2. Unit Testing
- ☰ 19.3. Integration Testing
- ☰ 19.4. API Testing
- ☰ 19.5. pytest
- ☰ 19.6. Fixtures
- ☰ 19.7. Mocking
- ☰ 19.8. Testing Databases
- ☰ 19.9. Testing Authentication
- ☰ 19.10. Testing FastAPI
- ☰ 19.11. Test Coverage
- ☰ 19.12. Automated Testing
-
- ☰ 20. Logging and Monitoring
- ☰ 20.1. Application Logging
- ☰ 20.2. Log Levels
- ☰ 20.3. Structured Logging
- ☰ 20.4. Request Logging
- ☰ 20.5. Error Logging
- ☰ 20.6. Metrics
- ☰ 20.7. Health Checks
- ☰ 20.8. Monitoring
- ☰ 20.9. Prometheus
- ☰ 20.10. Grafana
- ☰ 20.11. Alerting
- ☰ 20.12. Error Tracking
- ☰ 20.13. Observability Basics
-
- ☰ 21. Docker
- ☰ 21.1. Introduction to Containers
- ☰ 21.2. Docker Architecture
- ☰ 21.3. Images
- ☰ 21.4. Containers
- ☰ 21.5. Dockerfiles
- ☰ 21.6. Building Images
- ☰ 21.7. Running Containers
- ☰ 21.8. Volumes
- ☰ 21.9. Networks
- ☰ 21.10. Docker Compose
- ☰ 21.11. FastAPI with Docker
- ☰ 21.12. PostgreSQL with Docker
- ☰ 21.13. Redis with Docker
- ☰ 21.14. Multi-Container Applications
- ☰ 21.15. Production Docker Best Practices
-
- ☰ 22. Web Servers and Reverse Proxies
- ☰ 22.1. Application Servers
- ☰ 22.2. Uvicorn
- ☰ 22.3. Gunicorn
- ☰ 22.4. Reverse Proxies
- ☰ 22.5. Nginx
- ☰ 22.6. Traefik
- ☰ 22.7. HTTPS
- ☰ 22.8. TLS Certificates
- ☰ 22.9. Let's Encrypt
- ☰ 22.10. Load Balancing
-
- ☰ 23. Deployment
- ☰ 23.1. Development vs Production
- ☰ 23.2. Preparing an Application for Production
- ☰ 23.3. Linux Server Setup
- ☰ 23.4. Deploying with Docker
- ☰ 23.5. Environment Configuration
- ☰ 23.6. Managing Secrets
- ☰ 23.7. HTTPS Configuration
- ☰ 23.8. Production Logging
- ☰ 23.9. Backups
- ☰ 23.10. Zero-Downtime Deployment
- ☰ 23.11. Rollbacks
-
- ☰ 24. CI/CD
- ☰ 24.1. Introduction to CI/CD
- ☰ 24.2. Continuous Integration
- ☰ 24.3. Continuous Delivery
- ☰ 24.4. Continuous Deployment
- ☰ 24.5. CI/CD Pipelines
- ☰ 24.6. GitHub Actions
- ☰ 24.7. GitLab CI/CD
- ☰ 24.8. Building Docker Images
- ☰ 24.9. Container Registries
- ☰ 24.10. Deployment Pipelines
- ☰ 24.11. Staging Environments
- ☰ 24.12. Production Environments
- ☰ 24.13. Rollback Strategies
-
- ☰ 25. Backend Architecture
- ☰ 25.1. Monolithic Architecture
- ☰ 25.2. Modular Monoliths
- ☰ 25.3. Microservices
- ☰ 25.4. Layered Architecture
- ☰ 25.5. Service Layer
- ☰ 25.6. Separation of Concerns
- ☰ 25.7. Domain-Driven Design Basics
- ☰ 25.8. Event-Driven Architecture
- ☰ 25.9. Choosing an Architecture
-
- ☰ 26. Performance and Scalability
- ☰ 26.1. Understanding Backend Performance
- ☰ 26.2. CPU-Bound vs I/O-Bound Work
- ☰ 26.3. Asynchronous Programming
- ☰ 26.4. Database Optimization
- ☰ 26.5. Query Optimization
- ☰ 26.6. Indexing
- ☰ 26.7. Load Balancing
- ☰ 26.8. Horizontal Scaling
- ☰ 26.9. Vertical Scaling
- ☰ 26.10. Stateless Applications
- ☰ 26.11. Performance Testing
- ☰ 26.12. Load Testing
-
- ☰ 27. Advanced API Development
- ☰ 27.1. WebSockets
- ☰ 27.2. Server-Sent Events
- ☰ 27.3. GraphQL
- ☰ 27.4. Webhooks
- ☰ 27.5. Idempotency
- ☰ 27.6. API Rate Limiting
- ☰ 27.7. API Keys
- ☰ 27.8. API Gateways
- ☰ 27.9. Distributed APIs
- ☰ 27.10. Real-Time Applications
-
- ☰ 28. Production Backend Engineering
- ☰ 28.1. Configuration Management
- ☰ 28.2. Database Backups
- ☰ 28.3. Disaster Recovery
- ☰ 28.4. Graceful Shutdown
- ☰ 28.5. Fault Tolerance
- ☰ 28.6. Circuit Breakers
- ☰ 28.7. High Availability
- ☰ 28.8. Monitoring Production Systems
- ☰ 28.9. Incident Response
-
- ☰ 29. Project 1: Task Management API
- ☰ 29.1. Project Requirements
- ☰ 29.2. Project Structure
- ☰ 29.3. Database Design
- ☰ 29.4. CRUD Operations
- ☰ 29.5. Validation
-
- ☰ 30. Project 2: Authentication System
- ☰ 30.1. User Registration
- ☰ 30.2. JWT Authentication
- ☰ 30.3. Role-Based Authorization
- ☰ 30.4. Security Testing
-
- ☰ 31. Project 3: E-Commerce Backend
- ☰ 31.1. Architecture
- ☰ 31.2. User Management
- ☰ 31.3. Product Management
- ☰ 31.4. Categories
- ☰ 31.5. Shopping Cart
- ☰ 31.6. Orders
- ☰ 31.7. Inventory
- ☰ 31.8. Payments
- ☰ 31.9. Admin API
-
- ☰ 32. Final Project: Production Backend
- ☰ 32.1. Planning the Application
- ☰ 32.2. Designing the Architecture
- ☰ 32.3. Designing the Database
- ☰ 32.4. Building the REST API
- ☰ 32.5. Authentication and Authorization
- ☰ 32.6. PostgreSQL Integration
- ☰ 32.7. Redis Integration
- ☰ 32.8. Background Workers
- ☰ 32.9. File Storage
- ☰ 32.10. Dockerizing the Application
- ☰ 32.11. CI/CD Pipeline
- ☰ 32.12. Production Deployment
- ☰ 32.13. HTTPS and Domain Setup
- ☰ 32.14. Performance Optimization
- ☰ 32.15. Security Review
- ☰ 32.16. Documentation
-
- ☰ 33. Backend Developer Roadmap
- ☰ 33.1. What You Should Know Now
- ☰ 33.2. Building a Portfolio
- ☰ 33.3. Creating Backend Projects
- ☰ 33.4. Contributing to Open Source
- ☰ 33.5. Preparing for Backend Interviews
- ☰ 33.6. Backend Interview Questions
- ☰ 33.7. Database Interview Questions
- ☰ 33.8. API Interview Questions
- ☰ 33.9. Linux and Docker Interview Questions
- ☰ 33.10. Where to Go Next
-
Comments
Please login to add a comment.
Don't have an account? Register now!