15.5. Cross-Site Request Forgery
Table of Contents
Understanding Cross-Site Request Forgery
Cross-Site Request Forgery, usually written as CSRF or XSRF, is a common and very dangerous web attack. It abuses the trust that a server has in a user’s browser. As a backend developer, you must understand how it works and how to defend against it.
This chapter focuses on CSRF specifically, not on all web security topics.
What CSRF Is
In a CSRF attack, an attacker tricks a user’s browser into sending a request to a website where the user is already logged in.
Key ideas:
- The victim is authenticated, for example logged in to
bank.com. - The attacker creates a malicious page or link.
- The victim visits the malicious page.
- The victim’s browser automatically includes authentication data, such as cookies or session identifiers, when calling
bank.com. bank.comreceives a valid, authenticated request, and if it does not defend against CSRF, it may execute the action.
The request really comes from the victim’s browser, so from the server’s point of view it looks legitimate.
Why CSRF Is Dangerous
CSRF is dangerous when:
- The request changes state, for example transferring money, changing email, changing password, deleting data.
- Authentication uses something automatically sent by the browser, for example cookies or HTTP basic authentication.
- The server does not verify that the user actually intended to perform the action.
Typical CSRF impact:
- Changing account email so the attacker can reset the password later.
- Transferring money from the victim’s bank account.
- Changing application settings, for example enabling admin access or disabling security features.
- Deleting or changing important data in an admin panel.
CSRF is less dangerous for simple read-only actions, for example a GET request that returns your profile, but it is still best practice to protect any endpoint that changes state.
Basic CSRF Attack Example
Imagine a banking site:
- Domain:
https://bank.example - User is logged in and has a session cookie:
session=abc123. - This endpoint transfers money:
POST /transfer HTTP/1.1
Host: bank.example
Cookie: session=abc123
Content-Type: application/x-www-form-urlencoded
to=ATTACKER_ACCOUNT&amount=1000If the bank does not protect this endpoint, an attacker can create this HTML:
<!-- attack.html hosted on attack.example -->
<html>
<body>
<form action="https://bank.example/transfer" method="POST">
<input type="hidden" name="to" value="ATTACKER_ACCOUNT" />
<input type="hidden" name="amount" value="1000" />
</form>
<script>
document.forms[0].submit();
</script>
</body>
</html>Attack flow:
- Victim logs in to
https://bank.example. - The bank sets the
sessioncookie. - Victim later visits
http://attack.example/attack.html. - The page automatically submits the form to
https://bank.example/transfer. - Browser automatically attaches the
session=abc123cookie to the request. bank.examplereceives an authenticated POST request to transfer money.
From the bank’s perspective, this is a legitimate, logged-in request. If there is no CSRF protection, the transfer succeeds.
Why Browsers Help the Attacker
The browser automatically includes cookies for a domain on every request to that domain. This is normal behavior. That means:
- If you are logged in to
site.com, - and you visit another site that makes a request to
site.com, - then your browser will still send your
site.comcookies with that request.
This is the core reason CSRF works.
The attacker cannot read the response from site.com because of the Same Origin Policy, but for many attacks they do not need to read the response. They only need the server to perform an action.
Common CSRF Attack Techniques
Hidden Forms and Auto Submit
The most classic approach uses an HTML form with hidden inputs and method="POST":
<form action="https://app.example/change-email" method="POST">
<input type="hidden" name="email" value="attacker@example.com" />
</form>
<script>
document.forms[0].submit();
</script>The victim sees a normal page. The form is invisible and auto-submits when the page loads.
Image Tags and GET Requests
If a dangerous action uses GET, it is even easier to exploit:
<!-- Changing email with a GET request is a bad design -->
<img src="https://app.example/change-email?email=attacker@example.com" />As soon as the page loads, the browser requests the image. Because the URL is actually a state-changing endpoint, the action happens.
JavaScript and Third Party Sites
If a site allows external content, for example user-created HTML in comments or profiles, an attacker may embed CSRF attacks inside that content.
Even without JavaScript, simple embedded forms or images can be enough.
When CSRF Is Possible
CSRF usually requires three conditions:
- The victim has an active session or automatic authentication to the target site.
- The target site uses cookies or other auto-sent credentials, not explicit tokens in headers that the attacker can not set.
- A state-changing endpoint does not check if the request actually came from the site.
Important detail: CSRF is about abusing the browser’s automatic behavior. If the attacker must call your API from their own backend without using the victim’s browser, that is not CSRF. That is a different type of attack.
CSRF vs XSS
CSRF and XSS are different but often related.
- CSRF uses the victim’s browser to send authenticated requests to a target site but does not necessarily execute scripts on the target site.
- XSS (Cross-Site Scripting) injects and runs attacker-controlled JavaScript in the target site itself.
XSS is often more powerful: if an attacker has XSS, they can often perform CSRF-like actions through JavaScript. However, you must still implement CSRF protections, because CSRF can exist even when you have no XSS.
You will learn more about XSS in the dedicated chapter, so here we just note the difference.
Core CSRF Defense Strategies
Most CSRF defenses try to ensure that a state-changing request is really initiated by your site, not by a third party.
Typical strategies:
- CSRF tokens (synchronizer tokens).
- SameSite cookie attribute.
- Custom headers with non-cookie authentication, such as bearer tokens.
- Checking the Origin or Referer header.
- Avoiding dangerous GET requests.
You usually combine several of these for stronger security.
Rule: Every state-changing action that uses cookie-based authentication must be protected against CSRF.
CSRF Tokens (Synchronizer Tokens)
The CSRF token pattern is the main defense for traditional web apps with server-rendered HTML and cookie-based sessions.
Basic Idea
- Backend generates a random, secret token for a user session.
- Backend stores this token server side, for example in the session.
- Backend also sends this token to the client, for example in an HTML form.
- When the client sends a state-changing request, it must include the token.
- Backend checks that the received token matches the expected token.
An attacker cannot read the token from the legitimate site. They also cannot guess it if it is random enough.
Example: Server Rendered Form
In a Python template (for example Jinja2):
<form action="/change-email" method="POST">
<input type="hidden" name="csrf_token" value="{{ csrf_token }}" />
<input type="email" name="email" />
<button type="submit">Change email</button>
</form>Server side code (conceptual):
from secrets import token_urlsafe
def generate_csrf_token(session):
if "csrf_token" not in session:
session["csrf_token"] = token_urlsafe(32)
return session["csrf_token"]
def validate_csrf_token(session, token_from_form):
expected = session.get("csrf_token")
if not expected or token_from_form != expected:
raise ValueError("Invalid CSRF token")Workflow:
- When rendering the page,
generate_csrf_tokenis called. It stores and returns the token, which is placed in the form. - When the user submits the form, the backend receives
csrf_tokenand callsvalidate_csrf_token. - If there is no CSRF token or it does not match, the server rejects the request.
Even if an attacker forces the victim’s browser to submit the form, they cannot know the correct csrf_token value, so the request fails.
Double Submit Cookie Pattern
Sometimes you cannot or do not want to store a token in the session. Another common pattern is the double submit cookie.
Idea:
- Server sends a random CSRF token in a cookie and also makes the client include it in a custom header or request body.
- Server receives both.
- If the value from the body or header does not match the cookie, the request is rejected.
Because JavaScript on an attacker’s site cannot read your cookies, they cannot know the correct token to put in the header or body.
Example:
- Server sets cookie:
Set-Cookie: csrf_token=RANDOM_VALUE; Path=/; Secure; HttpOnly- A JavaScript frontend on the same origin reads the non-HttpOnly CSRF cookie and sends it in a header:
const csrfToken = getCookie("csrf_token"); // your own function
fetch("/change-email", {
method: "POST",
headers: {
"X-CSRF-Token": csrfToken,
"Content-Type": "application/json"
},
body: JSON.stringify({ email: "new@example.com" })
});- The server compares:
def validate_csrf(request):
token_cookie = request.cookies.get("csrf_token")
token_header = request.headers.get("X-CSRF-Token")
if not token_cookie or not token_header or token_cookie != token_header:
raise ValueError("Invalid CSRF token")
Note that for this pattern, the CSRF cookie must be readable by JavaScript, so usually you do not set HttpOnly on that specific cookie.
SameSite Cookies
The SameSite cookie attribute tells the browser when cookies can be sent with cross-site requests.
The possible values are:
| Value | Behavior summary |
|---|---|
Strict | Cookie is sent only for requests that come from the same site. |
Lax | Cookie is sent for top-level navigations with safe methods (GET). |
None | Cookie is sent in all contexts, requires Secure. |
If you set session cookies with SameSite=Lax or SameSite=Strict, some CSRF attacks are blocked by the browser itself.
Example cookie header:
Set-Cookie: session=abc123; Path=/; HttpOnly; Secure; SameSite=LaxEffect:
- A form POST from another site will not include this cookie in many modern browsers.
- A normal link click to your site with GET may still send the cookie when
Laxis used.
Caveats:
- Browsers implement SameSite behavior slightly differently, and old browsers may ignore it.
SameSite=NonerequiresSecure.- SameSite is a mitigation, not a full solution. You should still use CSRF tokens for important operations.
Rule: Always set SameSite on your cookies. Use SameSite=Lax or SameSite=Strict where possible.
Custom Headers and Token Based Auth
When an API is used by a single-page application (SPA) that obtains a token and sends it in an Authorization header, CSRF is usually less of an issue.
Example:
POST /change-email HTTP/1.1
Host: api.example
Authorization: Bearer eyJhbGciOi...
Content-Type: application/json
{"email": "new@example.com"}In this model:
- The attacker cannot force the victim’s browser to set arbitrary
Authorizationheaders to arbitrary domains using simple HTML. - To send
Authorizationheaders with a cross-originfetch, the attacker’s page would need to bypass CORS and also somehow obtain the victim’s token, which is harder.
However, if your tokens are stored in cookies and sent automatically, CSRF problems return, because the browser auto-includes the cookie.
So, for APIs:
- Using bearer tokens in headers,
- Storing them in memory or local storage, not cookies,
- And enabling proper CORS,
usually reduces CSRF risks. But you must be careful with XSS and other issues, which can then expose tokens.
Origin and Referer Validation
Another line of defense against CSRF is to check the Origin or Referer headers.
Originheader indicates the origin of the request, for examplehttps://app.example.Refererindicates the full URL of the page that initiated the request.
Server side check example:
ALLOWED_ORIGINS = {"https://app.example"}
def validate_origin(request):
origin = request.headers.get("Origin") or ""
if origin not in ALLOWED_ORIGINS:
raise ValueError("Invalid origin")
If your site receives a POST request from https://evil.example, you can detect it and reject the request.
Problems:
- Not all requests contain
OriginorRefererheaders, for example some older browsers or privacy tools may strip them. - Attackers can sometimes cause these headers to be missing, leading to possible false negatives or requiring you to define how to handle missing values.
Therefore, origin checks are a useful additional protection but should not be your only CSRF defense.
Safe HTTP Methods and CSRF
CSRF is most relevant for requests that change state.
HTTP defines some methods as safe, in particular GET, HEAD, and OPTIONS. Safe methods should not change the server state.
Rule: Do not perform state-changing actions in GET requests. Use POST, PUT, PATCH, or DELETE instead.
If you follow this rule, then:
- CSRF attacks must target non-safe methods like POST.
- It becomes clearer which endpoints must have CSRF protection.
Example of bad design:
GET /delete-user?id=123This is vulnerable to simple CSRF, for example:
<img src="https://admin.example/delete-user?id=123" />Better design:
POST /users/123/deleteAnd protect this POST endpoint with CSRF tokens and other defenses.
CSRF in Modern SPAs and APIs
Modern single page apps often use:
- JSON APIs,
- Bearer tokens in headers,
- CORS for cross-origin protection.
In this environment, CSRF risks change:
- If authentication is done entirely with a header, and tokens are not stored in cookies, traditional CSRF is less likely.
- The main risk becomes token theft through XSS or other vulnerabilities.
- However, if you still use cookies for some parts, or allow cookie-based sessions for admins, you still need CSRF protections for those endpoints.
Typical patterns:
| Scenario | CSRF risk | Defense |
|---|---|---|
| Cookie-based session, server-rendered HTML | High | CSRF tokens, SameSite, origin checks |
SPA with JWT in Authorization header | Lower, but XSS high risk | CORS, XSS protection, secure token handling |
| API consumed by third party sites via CORS | Depends on design | Strict CORS, token auth, avoid cookies |
When in doubt, treat cookie-authenticated endpoints as CSRF vulnerable.
Practical Backend CSRF Checklist
For backend developers, here is a short practical list.
Checklist for CSRF Protection
- All state-changing endpoints require CSRF tokens when using cookie-based sessions.
- No state-changing action is exposed through GET requests.
- Session cookies are set with
HttpOnly,Secure, andSameSite=LaxorSameSite=Strictwhen possible. - Consider origin or referer checks for sensitive actions, for example money transfers.
- For APIs, prefer token-based authentication in headers instead of cookies.
- Document which endpoints are protected by CSRF middleware or decorators.
Small End to End Example
Imagine a simple profile update endpoint in a traditional backend.
Step 1: Set up CSRF Token on Login
When a user logs in, the server:
- Creates a session.
- Generates a CSRF token and stores it in the session.
def login(request):
user = authenticate(request)
session_id = create_session(user.id)
csrf_token = token_urlsafe(32)
store_in_session(session_id, {"csrf_token": csrf_token})
response = make_response("OK")
response.set_cookie("session_id", session_id, httponly=True, secure=True, samesite="Lax")
return responseStep 2: Render a Protected Form
def show_profile_form(request):
session = get_session(request.cookies.get("session_id"))
csrf_token = session["csrf_token"]
return render_template("profile.html", csrf_token=csrf_token)
profile.html:
<form action="/profile" method="POST">
<input type="hidden" name="csrf_token" value="{{ csrf_token }}" />
<label>
Name:
<input type="text" name="name" />
</label>
<button type="submit">Save</button>
</form>Step 3: Validate on Submit
def update_profile(request):
session = get_session(request.cookies.get("session_id"))
expected_token = session.get("csrf_token")
submitted_token = request.form.get("csrf_token")
if not expected_token or submitted_token != expected_token:
return error_response("Invalid CSRF token", status=403)
# Now safe to update
name = request.form.get("name")
update_user_name(session["user_id"], name)
return success_response("Updated")Attack result:
- If an attacker hosts a form to
/profilewithout the correctcsrf_tokenvalue, the check fails and the profile is not updated, even though the victim is logged in.
Summary
You have seen that:
- CSRF abuses automatic browser behavior, especially cookies.
- It allows attackers to trigger unwanted actions on behalf of logged in users.
- It is especially dangerous for state-changing endpoints that use cookie-based sessions.
- Core defenses are CSRF tokens, SameSite cookies, avoiding state changes in GET, origin checks, and using header-based tokens for APIs.
As a backend developer, you must always ask: "If the victim is logged in, can an attacker make their browser perform this action without their knowledge?" If the answer is yes, you need CSRF protection.
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!