5.9. Working with Files
Table of Contents
Why File Handling Matters for Backend Developers
Working with files is a core backend task. You will often need to:
- Store logs, configuration, or temporary data.
- Read templates, certificates, or static content.
- Process user generated files, for example CSV imports or report exports.
- Integrate with other systems through file based interfaces.
In this chapter you will learn how to work with files in Python in a safe and backend friendly way.
Always treat file handling as an I/O operation that can fail. Never assume a file exists, is readable, or has valid content. Always validate and handle errors.
We will assume you already know basic Python syntax, functions, and exceptions from earlier chapters, and focus here on what is unique to file handling.
Paths and Directories
Before opening a file, you need to know where it is located. Backend projects usually handle two kinds of files:
- Project files: inside your project repository, for example templates, fixtures, or seed data.
- External files: uploaded by users or written as logs, exports, or temporary data.
Absolute vs Relative Paths
A path is a string that tells the operating system where a file is.
- Absolute path: starts from the root of the file system.
- Linux:
/var/log/app.log - Windows:
C:\logs\app.log - Relative path: relative to the current working directory of the Python process.
# Suppose current directory is /home/app
logs/app.log # refers to /home/app/logs/app.log
../config/app.yml # refers to /home/config/app.yml
In backend applications, you often want to avoid plain string paths and instead use pathlib.
Using pathlib for Safer Paths
pathlib gives you an object oriented way to work with paths and is cross platform.
from pathlib import Path
# Current working directory
cwd = Path.cwd()
print(cwd)
# Absolute path to a file in a "data" subdirectory
data_file = cwd / "data" / "users.csv"
print(data_file)
# Check if a file or directory exists
print(data_file.exists()) # True or False
print(data_file.is_file()) # True if it is a file
print(data_file.is_dir()) # True if it is a directory
Using the / operator with Path joins segments in a platform independent way.
In many backend apps you will want a path relative to the project root or the file containing your code, not the current working directory.
from pathlib import Path
# Path to this Python file
this_file = Path(__file__)
# Project root might be the parent of this file, or higher
project_root = this_file.parent.parent
config_file = project_root / "config" / "app.yml"This pattern is common when reading internal config or template files.
Opening and Closing Files
To read or write files, you use the built in open function. The most important part is to always close files properly.
The with Statement
You should almost always open files using a with block. This guarantees the file is closed even if an error occurs.
from pathlib import Path
log_path = Path("logs/app.log")
# Writing to a file
with open(log_path, mode="a", encoding="utf-8") as log_file:
log_file.write("Application started\n")
# Reading from a file
with open(log_path, mode="r", encoding="utf-8") as log_file:
content = log_file.read()
print(content)
As soon as Python leaves the with block, it automatically calls log_file.close() for you.
Rule: Always use with open(...) as f: for file operations to avoid resource leaks.
File Modes
The mode argument controls how you open the file.
| Mode | Description | Creates file? | Truncates existing? |
|---|---|---|---|
"r" | Read text | No | No |
"w" | Write text | Yes | Yes, clears file |
"a" | Append text at end | Yes | No |
"x" | Create new file, fail if exists | Yes | N/A |
"rb" | Read binary | No | No |
"wb" | Write binary | Yes | Yes |
"ab" | Append binary | Yes | No |
You can also combine with + for reading and writing, for example "r+", "w+", "a+", but for backend code this is less common and often less clear.
Use encoding="utf-8" for text to avoid encoding problems.
Reading Files
You often need to read configuration files, templates, or data imports.
Reading Entire File
Use .read() when the file is reasonably small, for example under a few megabytes.
from pathlib import Path
config_path = Path("config/settings.json")
with open(config_path, mode="r", encoding="utf-8") as config_file:
content = config_file.read()
print(content)Reading Line by Line
For larger files, you should not load the whole file into memory at once. Instead, iterate line by line.
from pathlib import Path
log_path = Path("logs/app.log")
with open(log_path, mode="r", encoding="utf-8") as log_file:
for line in log_file:
# Remove trailing newline
line = line.rstrip("\n")
print(line)This pattern is very useful when you process large CSV exports or other line based logs.
You can also use .readline() or .readlines(), but the simple for line in file is usually best.
Handling Missing Files
When a file does not exist, open raises FileNotFoundError. In backend code, you should handle this gracefully.
from pathlib import Path
def read_optional_config(path: Path) -> str | None:
try:
with open(path, mode="r", encoding="utf-8") as f:
return f.read()
except FileNotFoundError:
# Config is optional, just return None
return NoneIf a file is required, you might want to log a clear error and re raise the exception instead.
Writing Files
Backends often write logs, temporary files, exports, and cached data.
Overwriting vs Appending
- Use
"w"to create or overwrite a file. - Use
"a"to append to a file.
from pathlib import Path
output_path = Path("output/report.txt")
# Overwrite any existing file
with open(output_path, mode="w", encoding="utf-8") as report:
report.write("User Report\n")
report.write("===========\n")
# Append a line later
with open(output_path, mode="a", encoding="utf-8") as report:
report.write("User: alice\n")
Be careful with "w" because it clears the file before writing.
Never open important data files in "w" mode unless you really want to erase existing content. Use "a" or explicit backups instead.
Ensuring Directories Exist
If you write to logs/app.log and the logs directory does not exist, open will fail. You should ensure directories exist.
from pathlib import Path
log_dir = Path("logs")
log_dir.mkdir(parents=True, exist_ok=True)
log_path = log_dir / "app.log"
with open(log_path, mode="a", encoding="utf-8") as log_file:
log_file.write("Application started\n")parents=Truecreates all missing parent directories.exist_ok=Truedoes not raise an error if the directory already exists.
Text vs Binary Files
Backends deal with both plain text files and binary files such as images, PDFs, or archives.
Text Files
Use text mode (for example "r", "w", "a") when the content is textual, such as JSON, CSV, logs, or source code.
from pathlib import Path
env_file = Path(".env")
with open(env_file, "r", encoding="utf-8") as f:
for line in f:
print(line.strip())Binary Files
Use binary mode ("rb", "wb", "ab") for non text content, for example:
- Images (JPEG, PNG)
- Documents (PDF, DOCX)
- Compressed files (ZIP, GZIP)
from pathlib import Path
image_path = Path("images/logo.png")
copy_path = Path("images/logo_copy.png")
with open(image_path, "rb") as src, open(copy_path, "wb") as dst:
# Copy bytes in chunks
while chunk := src.read(8192):
dst.write(chunk)Note how we use a chunk size (here 8192 bytes) to avoid loading the entire file into memory. This is important for large files in backend systems.
Common Patterns for Backend File Handling
Backend applications often reuse a few typical patterns for file work.
Reading Configuration from Files
You might have configuration in JSON, YAML, or a simple key value format.
Example: simple KEY=VALUE configuration file.
from pathlib import Path
def load_simple_env(path: Path) -> dict[str, str]:
config: dict[str, str] = {}
try:
with open(path, "r", encoding="utf-8") as f:
for line in f:
line = line.strip()
# Skip empty lines and comments
if not line or line.startswith("#"):
continue
key, sep, value = line.partition("=")
if sep != "=":
# Ignore invalid lines
continue
config[key.strip()] = value.strip()
except FileNotFoundError:
# Optional config
return config
return config
env_config = load_simple_env(Path(".env"))
print(env_config)
This is similar to what many web frameworks do internally when loading .env files.
Processing Uploaded Files
In a web backend, an uploaded file often arrives as bytes. Even though the framework may already manage the streaming, you sometimes need to save the uploaded data to disk.
A typical pattern:
from pathlib import Path
def save_uploaded_file(base_dir: Path, filename: str, content: bytes) -> Path:
base_dir.mkdir(parents=True, exist_ok=True)
file_path = base_dir / filename
with open(file_path, "wb") as f:
f.write(content)
return file_pathIn a real FastAPI endpoint, you would receive the content differently, but the core binary write pattern is the same.
Generating Export Files
Backends often create CSV or text exports.
from pathlib import Path
from typing import Iterable
def export_users_to_csv(path: Path, users: Iterable[dict]) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
with open(path, "w", encoding="utf-8") as f:
# Write header
f.write("id,username,email\n")
for user in users:
line = f"{user['id']},{user['username']},{user['email']}\n"
f.write(line)
users_data = [
{"id": 1, "username": "alice", "email": "alice@example.com"},
{"id": 2, "username": "bob", "email": "bob@example.com"},
]
export_users_to_csv(Path("exports/users.csv"), users_data)Later, another part of your system might serve this file as a download.
Safe and Secure File Handling
File handling is also a security sensitive area for backends.
Avoid User Controlled Paths
Never let users control full paths directly. For example, this is dangerous:
# Dangerous: user can access arbitrary files
def read_log_file(file_name: str) -> str:
with open(file_name, "r", encoding="utf-8") as f:
return f.read()
A malicious user could pass "../../etc/passwd" and read system files.
Instead, restrict file operations to a specific directory and clean the file name.
from pathlib import Path
LOGS_DIR = Path("logs").resolve()
def safe_read_log_file(file_name: str) -> str:
# Only allow simple names without path separators
if "/" in file_name or "\\" in file_name:
raise ValueError("Invalid file name")
file_path = (LOGS_DIR / file_name).resolve()
# Ensure the resolved path is still inside LOGS_DIR
if not str(file_path).startswith(str(LOGS_DIR)):
raise ValueError("Invalid file path")
with open(file_path, "r", encoding="utf-8") as f:
return f.read()This pattern helps prevent directory traversal attacks.
Validate File Sizes
Users can upload very large files that might exhaust memory or disk space.
A common pattern is to check the file size before fully processing it, or process in chunks and stop if the limit is exceeded.
Pseudo pattern:
MAX_FILE_SIZE = 10 * 1024 * 1024 # 10 MB
def validate_file_size(file_path: Path) -> None:
size = file_path.stat().st_size
if size > MAX_FILE_SIZE:
raise ValueError("File too large")Or, if you stream the content, you can count bytes as you read them and stop early.
Handle Errors Gracefully
Many things can go wrong with files:
FileNotFoundError: missing file.PermissionError: no rights to read or write.IsADirectoryError: tried to open a directory as a file.OSError: general I/O error, disk full, etc.
Typical backend pattern:
from pathlib import Path
def read_template(path: Path) -> str:
try:
with open(path, "r", encoding="utf-8") as f:
return f.read()
except FileNotFoundError:
# Log and re raise, or fallback to a default template
raise RuntimeError(f"Template not found: {path}")
except PermissionError:
raise RuntimeError(f"No permission to read template: {path}")
Central error handling higher in your stack can then convert RuntimeError into a proper HTTP response.
Temporary Files
Temporary files are useful when you need to hold data briefly, for example for an external tool, before deleting it again.
The tempfile module in the standard library helps with this.
import tempfile
from pathlib import Path
def create_temp_report(content: str) -> Path:
# Creates a named temporary file that we can reopen
with tempfile.NamedTemporaryFile(
mode="w",
encoding="utf-8",
delete=False, # Do not delete automatically
suffix=".txt",
prefix="report_",
) as tmp:
tmp.write(content)
temp_path = Path(tmp.name)
# Later we can serve or move this file
return temp_path
report_path = create_temp_report("Temporary report content")
print("Temp report at:", report_path)Backends often combine this with cron jobs or cleanup tasks that remove old temporary files.
Binary Streaming and Large Files
For very large files, you must avoid reading everything into memory at once.
The chunk pattern applies for both reading and writing:
from pathlib import Path
def copy_large_file(src: Path, dst: Path, chunk_size: int = 1024 * 1024) -> None:
with open(src, "rb") as f_src, open(dst, "wb") as f_dst:
while True:
chunk = f_src.read(chunk_size)
if not chunk:
break
f_dst.write(chunk)This is similar to what a web framework does internally when it streams a file to a client.
Summary
In backend development, file handling is about:
- Using
pathlibfor safe and portable path management. - Always using
with open(...)to ensure files are closed. - Choosing the correct mode, text vs binary, and being careful with
"w". - Reading files efficiently, especially when they are large.
- Creating directories before writing and handling errors robustly.
- Protecting against security issues such as directory traversal and huge uploads.
- Using temporary files and chunked streaming when needed.
These patterns will appear again when you handle uploads, downloads, logs, and integrations in later chapters of this 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!