5.12. Logging
Table of Contents
Why Logging Matters
When you run a backend application, things will go wrong. Users will see errors, performance will change, external services will fail, and bugs will appear in production. Logging is how you see what your application is doing in the real world.
Logging gives you:
- A history of what happened in your app.
- Visibility into errors and failures.
- Clues to understand performance issues.
- Data for debugging problems that you cannot easily reproduce.
Without logs, production issues become guesswork. With logs, you can answer questions like:
- What request failed?
- Which user did it affect?
- What exception was raised and where?
- How often does this error happen?
In this chapter you will learn how to use Python’s built-in logging module effectively for backend development.
Basic Logging in Python
Python includes a standard logging module called logging. You do not need to install anything.
The simplest way to log:
import logging
logging.warning("Something might be wrong")
logging.error("Something is definitely wrong")When you run this script, you will see output like:
WARNING:root:Something might be wrong
ERROR:root:Something is definitely wrongBy default, Python logs:
- To standard error (stderr)
- Only messages with level WARNING or higher
You will learn about levels in detail shortly.
The `logging.debug` to `logging.critical` functions
The top-level logging.* functions are shortcuts that use a default logger named "root":
import logging
logging.debug("Debug info")
logging.info("Application started")
logging.warning("Low disk space")
logging.error("Error connecting to database")
logging.critical("System is down!")This is enough for small scripts or experiments. For real applications you will usually:
- Create named loggers.
- Configure levels and handlers.
- Use structured messages.
Logging Levels
Logging levels describe the importance or severity of a log message.
Python defines these common levels (from least to most severe):
| Level | Numeric value | Typical use case |
|---|---|---|
| DEBUG | 10 | Detailed information for debugging |
| INFO | 20 | General information about application flow |
| WARNING | 30 | Something unexpected, but the app can continue |
| ERROR | 40 | A serious problem, part of the app failed |
| CRITICAL | 50 | Very serious error, the application may crash |
Rule: Use DEBUG for developers, INFO for normal events, WARNING for unusual but handled situations, ERROR for failures of operations, CRITICAL for system-wide or unrecoverable problems.
Example usage:
import logging
logging.debug("Connecting to cache with config: %s", cache_config)
logging.info("User %s logged in", user_id)
logging.warning("User %s tried to access deprecated endpoint", user_id)
logging.error("Payment processing failed for order %s", order_id)
logging.critical("Database is unavailable, shutting down service")
Python will ignore messages below the configured level. For example, if the level is set to INFO, all DEBUG messages are skipped.
Getting and Using Loggers
Using the root logger everywhere is not ideal. In a larger application you want separate loggers for different modules.
`logging.getLogger(__name__)`
The usual pattern in Python modules:
# file: my_app/payments.py
import logging
logger = logging.getLogger(__name__)
def charge_card(user_id, amount):
logger.info("Charging card for user=%s amount=%s", user_id, amount)
# ...In another file:
# file: my_app/orders.py
import logging
logger = logging.getLogger(__name__)
def create_order(user_id, items):
logger.debug("Creating order for user=%s items=%s", user_id, items)
# ...Here:
__name__becomes"my_app.payments"inpayments.py.__name__becomes"my_app.orders"inorders.py.
This gives each module its own logger name, which is useful for filtering and formatting.
Why not use `print()`?
print() is simple, but:
- It has no levels.
- It is harder to disable or redirect.
- It cannot be easily sent to a file, JSON, or external systems.
- It does not integrate with frameworks and tools that expect logging.
Use logging for application messages. Use print() only for quick local debugging during development.
Configuring Logging with `basicConfig`
For small applications you can use logging.basicConfig to set up logging quickly.
import logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
)
logger = logging.getLogger(__name__)
logger.debug("Debug message") # Will not show, level is INFO
logger.info("Service starting")
logger.warning("Cache not available, using fallback")Example output:
2024-04-10 10:15:23,456 [INFO] my_app.main: Service starting
2024-04-10 10:15:23,457 [WARNING] my_app.main: Cache not available, using fallbackCommon `basicConfig` options
| Parameter | Description |
|---|---|
level | Minimum level to log. Example: logging.DEBUG, logging.INFO. |
format | Template for each log line, using placeholders like %(levelname)s. |
filename | If given, logs go to that file instead of the console. |
filemode | File open mode, for example "w" to overwrite, "a" to append. |
Example logging to a file:
logging.basicConfig(
level=logging.DEBUG,
filename="app.log",
filemode="a",
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
)
Now all logs go to app.log instead of the terminal.
Rule: Always call logging.basicConfig or a custom configuration once at application startup, usually in your main.py or entrypoint, not in every module.
Log Message Formatting
The format string can include many fields. Some common ones:
| Placeholder | Meaning |
|---|---|
%(asctime)s | Time of the log record |
%(levelname)s | Level as text, for example "INFO" |
%(name)s | Logger name, for example "my_app.api" |
%(message)s | The log message itself |
%(filename)s | File name that logged the message |
%(lineno)d | Line number in the source file |
%(funcName)s | Function name |
%(process)d | Process ID |
%(threadName)s | Thread name |
Example:
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s [%(levelname)s] %(name)s (%(filename)s:%(lineno)d): %(message)s",
)A log line might look like:
2024-04-10 10:16:01,123 [ERROR] my_app.auth (auth.py:42): Invalid token for user_id=123Logging Variables Safely
You often want to include variables in log messages.
Using `%s` formatting (recommended with logging)
The logging module expects you to use %s style placeholders and pass arguments separately:
order_id = 42
user_id = 7
logger.info("Created order %s for user %s", order_id, user_id)Why this style is better:
- Logging can skip formatting if the message is not emitted. For example, if level is too low, it avoids unnecessary string building.
- It is more efficient than f-strings for messages that might not be logged.
Avoid building strings manually
Avoid:
logger.info("Created order " + str(order_id) + " for user " + str(user_id))
logger.info(f"Created order {order_id} for user {user_id}")These always build the string first, even if the log is not written.
Logging Exceptions
Backend applications often fail with exceptions. You want to capture:
- The error message.
- The stack trace.
- Context such as user id or request path.
`logger.exception`
Inside an exception handler you can use logger.exception. It automatically adds the stack trace.
import logging
logger = logging.getLogger(__name__)
def process_order(order_id):
try:
# Code that may fail
result = 1 / 0
return result
except Exception:
logger.exception("Failed to process order %s", order_id)
raiseExample output:
2024-04-10 10:18:00,999 [ERROR] my_app.orders: Failed to process order 42
Traceback (most recent call last):
File "orders.py", line 7, in process_order
result = 1 / 0
ZeroDivisionError: division by zero
logger.exception always logs at the ERROR level, and must be called inside an except block.
Using `exc_info=True`
You can also pass exc_info=True to any logging method:
try:
connect_to_db()
except DatabaseError:
logger.error("Database connection failed", exc_info=True)
This has a similar effect, but logger.exception is usually simpler inside an except block.
Rule: When handling an exception that you might need to debug later, always log it with a stack trace, either with logger.exception or exc_info=True.
Handlers, Formatters, and Multiple Outputs
For small scripts basicConfig is enough. In backend services you often want logs to go to multiple places, for example:
- Console in development.
- Log files in production.
- External logging services.
This is possible with handlers.
What is a handler?
A handler decides where the log record goes.
Common handlers:
| Handler | Purpose |
|---|---|
StreamHandler | Logs to streams, for example console |
FileHandler | Logs to a file |
RotatingFileHandler | Logs to file with automatic rotation |
TimedRotatingFileHandler | Rotation based on time |
You can attach multiple handlers to the same logger.
Simple handler example
import logging
logger = logging.getLogger("my_app")
logger.setLevel(logging.DEBUG)
# Console handler
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
# File handler
file_handler = logging.FileHandler("app.log")
file_handler.setLevel(logging.DEBUG)
# Formatter
formatter = logging.Formatter(
"%(asctime)s [%(levelname)s] %(name)s: %(message)s"
)
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)
logger.addHandler(console_handler)
logger.addHandler(file_handler)
logger.debug("Debug message, only in file")
logger.info("Info message, in console and file")
logger.error("Error message, in console and file")Here:
loggerhas level DEBUG so it accepts all messages.console_handleronly emits INFO and above.file_handleremits DEBUG and above.
So:
debuggoes to file only.infoanderrorgo to both console and file.
Handler hierarchy and propagation
Loggers have a hierarchy based on their names.
Example:
- Logger
"my_app"is the parent. - Logger
"my_app.auth"is a child. - Logger
"my_app.auth.jwt"is a grandchild.
If propagate is True (default), a record from "my_app.auth" goes:
- To handlers attached to
"my_app.auth". - Then to handlers attached to
"my_app". - And further up to
"root"if propagation continues.
You can disable this by:
logger = logging.getLogger("my_app.auth")
logger.propagate = False
In many backends you attach handlers only to the root logger or a top level logger like "my_app", and let child loggers inherit the configuration.
Logging Configuration via Dictionary
For larger applications, writing configuration in code can become messy. Python allows configuration via a dictionary (or a YAML/JSON file that you load into a dict).
Simple dict configuration:
import logging
import logging.config
LOGGING_CONFIG = {
"version": 1,
"disable_existing_loggers": False,
"formatters": {
"standard": {
"format": "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
},
},
"handlers": {
"console": {
"class": "logging.StreamHandler",
"formatter": "standard",
"level": "INFO",
},
},
"loggers": {
"my_app": {
"handlers": ["console"],
"level": "DEBUG",
"propagate": False,
},
},
"root": {
"handlers": ["console"],
"level": "WARNING",
},
}
def configure_logging():
logging.config.dictConfig(LOGGING_CONFIG)Then in your main entrypoint:
from my_app.logging_config import configure_logging
configure_logging()
logger = logging.getLogger("my_app.api")
logger.info("API started")Benefits:
- You can manage logging configuration separately from application logic.
- Easier to adjust per environment.
Logging in Different Environments
Backend services often behave differently in development and production.
Development logging
Typical development setup:
- Level: DEBUG or INFO.
- Human friendly format, more details (like file name and line).
- Log to console.
Example:
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s [%(levelname)s] %(name)s (%(filename)s:%(lineno)d): %(message)s",
)Production logging
Typical production setup:
- Level: INFO or WARNING.
- More concise format, maybe JSON.
- Log to stdout or to files that are rotated.
- Avoid sensitive data in logs.
Example code pattern:
import logging
import os
LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
logging.basicConfig(
level=LOG_LEVEL,
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
)You can then change the level without code changes:
LOG_LEVEL=DEBUG python app.pyRule: Never log secrets such as passwords, API keys, or full credit card numbers. Logs can be copied, shared, and stored for a long time.
Structured Logging Basics
When your application grows, plain text logs become harder to search and analyze. Many production systems prefer structured logs, often as JSON.
A structured log is a log entry that has consistent fields, for example:
{
"time": "2024-04-10T10:20:30Z",
"level": "INFO",
"logger": "my_app.api",
"message": "User logged in",
"user_id": 123,
"ip": "203.0.113.5",
"request_id": "abc-123"
}
In Python, you can approximate structured logging using the extra parameter.
Using `extra` for additional fields
import logging
logger = logging.getLogger("my_app.api")
def login(user_id, ip, request_id):
logger.info(
"User logged in",
extra={
"user_id": user_id,
"ip": ip,
"request_id": request_id,
},
)You also need a formatter that uses these fields:
formatter = logging.Formatter(
"%(asctime)s [%(levelname)s] %(name)s user_id=%(user_id)s ip=%(ip)s request_id=%(request_id)s: %(message)s"
)If some logs do not have those fields you will get formatting errors, so in real applications you often use custom formatters or third party libraries that handle missing fields and JSON output. For now, it is important to understand that:
extraallows you to attach structured data.- Formatters decide how to turn that data into a string or JSON.
Practical Patterns for Backend Logging
Here are some concrete patterns that work well in backend apps.
Pattern 1: Module level logger
In every module:
# my_app/users.py
import logging
logger = logging.getLogger(__name__)
def create_user(email: str):
logger.debug("Creating user with email=%s", email)
# validate, save to DB
logger.info("User created email=%s", email)Central configuration at startup:
# main.py
import logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
)
from my_app.app import start
if __name__ == "__main__":
start()Pattern 2: Logging around important operations
Example for handling requests:
def handle_request(request):
logger = logging.getLogger("my_app.http")
logger.info("Request started method=%s path=%s", request.method, request.path)
try:
response = process_request(request)
except Exception:
logger.exception("Unhandled error for path=%s", request.path)
# Return generic error response
raise
logger.info("Request finished path=%s status=%s", request.path, response.status_code)
return responseThis gives you a clear start and end for each request.
Pattern 3: Logging retries and fallbacks
When you call external services, you often implement retries and fallbacks.
import time
import logging
logger = logging.getLogger(__name__)
def call_payment_service(payload):
attempts = 3
for attempt in range(1, attempts + 1):
try:
logger.info("Calling payment service attempt=%s", attempt)
return _do_call_payment_service(payload)
except TimeoutError:
logger.warning("Payment service timeout attempt=%s", attempt)
time.sleep(1)
logger.error("Payment service failed after %s attempts", attempts)
raise RuntimeError("Payment service unavailable")Logs from this pattern help you see:
- How often timeouts occur.
- Whether retries succeed.
- When fallbacks or failures happen.
Common Logging Mistakes
Some typical mistakes to avoid:
| Mistake | Why it is a problem | Better approach |
|---|---|---|
Using print() everywhere | No levels, no control, hard to redirect | Use logging with appropriate levels |
| Logging too much at INFO or higher | Logs become noisy, storage costs increase | Use DEBUG for very detailed logs |
| Ignoring exceptions | Failures are invisible, hard to debug | Use logger.exception in except blocks |
| Logging sensitive data | Security and privacy risk | Mask or omit secrets and personal data |
| Not including context (user, request) | Hard to understand what a log line refers to | Include identifiers like user id, request id |
| Configuring logging in every module | Confusing configuration, duplicated code | Configure logging once in the application entrypoint |
Rule: Log only what you need and at the right level. Too many logs are almost as bad as no logs.
Small End-to-End Example
Here is a small, simplified backend-like example using what you have learned.
# main.py
import logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
)
from app import handle_request
if __name__ == "__main__":
fake_request = {
"path": "/orders",
"method": "POST",
"user_id": 123,
"body": {"items": [1, 2, 3]},
}
response = handle_request(fake_request)
print("Response:", response)# app.py
import logging
logger = logging.getLogger(__name__)
def handle_request(request):
path = request["path"]
method = request["method"]
user_id = request["user_id"]
logger.info("Request started method=%s path=%s user_id=%s", method, path, user_id)
try:
if path == "/orders" and method == "POST":
response = create_order(request)
else:
logger.warning("Unknown endpoint path=%s method=%s", path, method)
response = {"status": 404, "body": {"error": "Not found"}}
except Exception:
logger.exception("Unhandled error for path=%s user_id=%s", path, user_id)
response = {"status": 500, "body": {"error": "Internal server error"}}
logger.info(
"Request finished path=%s user_id=%s status=%s",
path,
user_id,
response["status"],
)
return response
def create_order(request):
user_id = request["user_id"]
items = request["body"]["items"]
logger.debug("Creating order for user_id=%s items=%s", user_id, items)
if not items:
logger.warning("Empty order for user_id=%s", user_id)
return {"status": 400, "body": {"error": "No items"}}
# Simulate some business logic
order_id = 42
logger.info("Order created order_id=%s user_id=%s", order_id, user_id)
return {"status": 201, "body": {"order_id": order_id}}Sample logs:
2024-04-10 10:30:00,101 [INFO] app: Request started method=POST path=/orders user_id=123
2024-04-10 10:30:00,102 [INFO] app: Order created order_id=42 user_id=123
2024-04-10 10:30:00,103 [INFO] app: Request finished path=/orders user_id=123 status=201This simple example demonstrates:
- Central logging configuration.
- Module level logger.
- INFO and WARNING messages.
- Logging request context.
You will build on these concepts when you integrate logging into full web frameworks and production deployments later in the course.
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!