15.12. Secrets Management
Table of Contents
Why Secrets Management Matters
In backend development you constantly work with sensitive values such as database passwords, API keys, encryption keys, and tokens. Collectively these are called secrets.
If secrets leak, attackers can often bypass your authentication and authorization, or directly connect to your database or third‑party services.
Never hard‑code secrets in your source code or commit them to version control.
This chapter focuses on how to store, access, and rotate secrets safely, not on authentication or encryption theory which are covered in other chapters.
What Counts as a Secret?
A secret is any value that must be kept confidential in order to keep your system secure.
Typical examples in backend systems:
| Type | Example value | Why it is sensitive |
|---|---|---|
| Database credentials | postgres://user:pass@db:5432/app | Lets an attacker access or destroy your data |
| API keys | sk_live_51N9... (Stripe secret key) | Lets attacker charge cards, refund payments, etc. |
| OAuth client secrets | GOOGLE_CLIENT_SECRET=abc123 | Lets attacker impersonate your app with Google |
| JWT signing keys | JWT_SECRET=super-secret-key | Lets attacker create valid tokens and impersonate users |
| Encryption keys | MASTER_KEY=base64:... | Lets attacker decrypt stored data |
| SSH keys | id_rsa private key | Lets attacker log into servers |
| SMTP credentials | SMTP_PASSWORD=mailpass | Lets attacker send email as your domain |
| Third‑party tokens | SLACK_BOT_TOKEN=xoxb-... | Lets attacker access external services |
| Cloud credentials | AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY | Lets attacker control your cloud resources |
Non‑examples:
- Public API URLs, like
https://api.stripe.com - Public keys (paired with private keys)
- Feature flags that are not security sensitive
As a simple rule:
If exposing a value would let an attacker do something harmful, treat it as a secret.
Common Mistakes with Secrets
Understanding what not to do makes good practices clearer.
Hard‑Coding Secrets in Source Code
Example of what you should avoid:
# config.py
DB_URL = "postgresql://user:mysecretpassword@localhost:5432/app_db"
JWT_SECRET = "super-secret-key-123"
STRIPE_SECRET_KEY = "sk_live_..."Problems:
- The secrets end up in Git history forever.
- Everyone with repository access gets full access to production systems.
- If you share your code publicly you automatically leak your secrets.
Committing Secret Files to Git
Example:
# .env
DATABASE_URL=postgresql://user:password@localhost:5432/app_db
JWT_SECRET=super-secret-key
If .env is tracked by Git:
- It is stored in the repository history and backups.
- It might end up in forks, mirrors, or public repos.
Always use a .gitignore entry for local secret files:
# .gitignore
.env
.env.*
secrets.jsonSharing Secrets Over Insecure Channels
Risky patterns:
- Sending database passwords in plain text chat.
- Emailing API keys without any protection.
- Copying secrets to random sticky notes or shared documents.
Better patterns:
- Use dedicated secret sharing tools or encrypted messaging.
- Use password managers with secure sharing features.
- Use one‑time secret URLs that expire after first read.
Principles of Good Secrets Management
These principles guide the techniques and tools you use.
Principle 1: Externalize Configuration
Configuration values, especially secrets, should come from outside your code.
Typical sources:
- Environment variables
- Configuration files that are not committed to Git
- Secrets management services (Vault, cloud secret managers)
Example pattern:
import os
DATABASE_URL = os.environ["DATABASE_URL"]
JWT_SECRET = os.environ["JWT_SECRET"]Your code knows how to read configuration, but not the actual values.
Principle 2: Least Privilege
Each component should have only the secrets it actually needs, and each secret should grant only the minimal permissions.
Examples:
- A read‑only database user for analytics instead of the full admin user.
- Per‑service API keys instead of a global key for all apps.
- Separate keys for development, staging, and production.
Principle 3: Separation of Environments
Never reuse the same secret across different environments.
Better structure:
| Environment | Database password | JWT secret | Stripe key |
|---|---|---|---|
| local | local_db_pass | local_jwt_secret | Test key sk_test_... |
| staging | staging_pass | staging_jwt | Test key sk_test_... |
| production | prod_pass | prod_jwt | Live key sk_live_... |
This keeps testing and experimentation from harming real users.
Principle 4: Rotate and Revoke
Secrets should be changeable and revocable without changing your code.
You should be able to:
- Replace a leaked secret with a new one.
- Roll keys regularly for high‑value secrets like JWT signing keys.
- Disable a token or API key that you no longer use.
Principle 5: Audit and Visibility
You should:
- Know who can access which secrets.
- Log secret access where possible.
- Monitor for unexpected access patterns.
This is mainly handled through secret management tools and cloud platforms.
Environment Variables for Secrets
Environment variables are often the simplest, first step to get secrets out of code.
Basics
In a Unix shell:
export DATABASE_URL="postgresql://user:password@localhost:5432/app_db"
export JWT_SECRET="super-secret-key"In Python:
import os
DATABASE_URL = os.environ["DATABASE_URL"]
JWT_SECRET = os.environ["JWT_SECRET"]
If a variable is missing, os.environ["KEY"] raises a KeyError. You can use .get with a fallback, but for secrets you usually require them.
JWT_SECRET = os.environ.get("JWT_SECRET")
if not JWT_SECRET:
raise RuntimeError("JWT_SECRET not set")Using .env Files Locally
Often you create a local .env file that defines environment variables:
# .env (do NOT commit this)
DATABASE_URL=postgresql://user:password@localhost:5432/app_db
JWT_SECRET=local-dev-secret
Then you use a library like python-dotenv to load it:
pip install python-dotenv# main.py
from dotenv import load_dotenv
import os
load_dotenv() # reads from .env
DATABASE_URL = os.environ["DATABASE_URL"]
JWT_SECRET = os.environ["JWT_SECRET"]
Important: Ensure .env is ignored by Git:
.envYou can keep a non secret example file:
# .env.example (commit this)
DATABASE_URL=postgresql://user:password@localhost:5432/app_db
JWT_SECRET=change-meThis shows other developers which variables are required without exposing your real secrets.
Using Environment Variables in Docker
With Docker, you can pass secrets as environment variables.
Example docker-compose.yml:
services:
api:
image: my-api
environment:
- DATABASE_URL=${DATABASE_URL}
- JWT_SECRET=${JWT_SECRET}
The ${VAR} values are taken from your shell environment or a .env file next to docker-compose.yml.
Example .env file for Docker:
DATABASE_URL=postgresql://user:password@db:5432/prod_db
JWT_SECRET=my-super-secretAgain, do not commit the real secrets to version control.
Storing Secrets in Configuration Files
Sometimes you store secrets in files that are not committed to Git and are loaded at runtime.
Example: secrets.json
{
"database_url": "postgresql://user:password@localhost:5432/app_db",
"jwt_secret": "super-secret-key"
}Python code:
import json
from pathlib import Path
config_path = Path("secrets.json")
config = json.loads(config_path.read_text())
DATABASE_URL = config["database_url"]
JWT_SECRET = config["jwt_secret"]Security notes:
- Add
secrets.jsonto.gitignore. - Limit file permissions so that only the application user can read it:
- On Linux:
chmod 600 secrets.json.
This pattern is simple but best used for local development or small deployments. For production you usually want a dedicated secret management system.
Dedicated Secret Management Systems
As your application grows, you want centralized tools designed to handle secrets safely and at scale.
Common systems:
| Tool | Typical usage |
|---|---|
| HashiCorp Vault | Self‑hosted or managed, very flexible |
| AWS Secrets Manager | Secrets in AWS environments |
| AWS Systems Manager (SSM) | Parameter store, including encrypted parameters |
| GCP Secret Manager | Secrets in Google Cloud |
| Azure Key Vault | Secrets, keys, and certificates in Azure |
Typical Features
Most secret managers provide:
- Encrypted storage of secrets at rest.
- Access control who or what can read a secret.
- Audit logging of secret access.
- Automatic rotation for some types of secrets.
- Versioning of secrets.
- Integration with cloud IAM roles and services.
Example: Conceptual Flow with a Secret Manager
High level example using a generic secret manager:
- You store a secret with a name and value:
- Name:
prod/database/url - Value:
postgresql://user:pass@db:5432/prod_db - Your application authenticates to the secret manager, usually with a non secret identity, for example:
- Cloud instance role.
- Kubernetes service account.
- Short‑lived credentials.
- Your application fetches the secret at startup:
from my_secret_client import get_secret
DATABASE_URL = get_secret("prod/database/url")- The secret manager logs the access and returns the decrypted value.
The exact client library and configuration depend on the platform, but the core idea is always similar.
Example: Secrets with AWS (Conceptual)
You do not need AWS experience to understand the pattern, it is similar on other clouds.
Using AWS Secrets Manager (High Level)
- In AWS Secrets Manager you create a secret:
- Name:
prod/myapp/db-credentials - Value (JSON):
{
"username": "myapp",
"password": "very-secret",
"host": "db.example.com",
"port": 5432
}- You give your EC2 instance or ECS task a role that allows reading this secret.
- In your app code you use the AWS SDK:
import boto3
import json
client = boto3.client("secretsmanager")
response = client.get_secret_value(SecretId="prod/myapp/db-credentials")
secret_dict = json.loads(response["SecretString"])
DATABASE_URL = (
f"postgresql://{secret_dict['username']}:{secret_dict['password']}"
f"@{secret_dict['host']}:{secret_dict['port']}/myapp_db"
)- No passwords are stored in source code or environment variables. The instance role identifies your application to AWS.
This pattern is similar with other providers: you create a secret, attach permissions to your compute resources, and fetch the secret in code at runtime.
Managing Different Environments
You should manage secrets per environment in a consistent way.
Naming Conventions
Conventions make your setup easier to understand.
For environment variables:
# local .env
APP_ENV=local
DATABASE_URL=postgresql://user:pass@localhost:5432/local_db
JWT_SECRET=local-secretFor staging:
# staging secrets
APP_ENV=staging
DATABASE_URL=postgresql://user:pass@staging-db:5432/staging_db
JWT_SECRET=staging-secretIn code:
import os
APP_ENV = os.environ.get("APP_ENV", "local")
DATABASE_URL = os.environ["DATABASE_URL"]
For secret managers you can prefix names, for example staging/myapp/db-url and prod/myapp/db-url.
Secret Value Differences
Across environments you may:
- Use test API keys in local and staging and live API keys in production.
- Use different JWT secrets, so a token from staging cannot be used in production.
- Use separate databases.
This reduces the blast radius of mistakes.
Secret Rotation and Revocation
You need to be able to change secrets safely.
When to Rotate
You should rotate secrets when:
- You suspect a leak.
- A team member with access leaves the company.
- A secret is accidentally printed in logs.
- You are updating security policies.
- Periodically, for high sensitivity secrets.
Basic Manual Rotation Pattern
Example: Rotating a database password.
- Create a new password for the same database user.
- Update the secret storage (env var, secret manager, config file) with the new password.
- Restart or reload the application so it uses the new password.
- Test that the app can connect with the new password.
- Revoke the old password or remove any old users.
If you cannot change the password for the same user, you can:
- Create a new user with a new password.
- Configure your app to support multiple connection strings for a transition period.
Rotating JWT Signing Keys (Conceptual)
JWT signing keys are critical. If a JWT secret leaks, an attacker can create valid tokens.
Basic approach:
- Introduce a key ID
kidin your JWT header. - Keep a map of
kid→ signing key in your backend. - Add a new key with a new
kidand start signing new tokens with it. - Keep old keys for some time to verify existing tokens.
- After all old tokens have expired, remove the old keys.
The detailed implementation belongs to the authentication chapters, but you should see how secret rotation affects token handling.
Handling Secrets in Development
Developers still need secrets to run the app locally, but you must avoid leaks.
Using .env Files Per Developer
Typical pattern:
- Each developer has their own
.envfile with local settings. - There is a
.env.examplewith placeholder values.
Example .env.example:
APP_ENV=local
DATABASE_URL=postgresql://user:password@localhost:5432/app_db
JWT_SECRET=change-me
STRIPE_SECRET_KEY=sk_test_...A new developer:
cp .env.example .env
# then edit .env with real local valuesThis keeps the structure visible while not sharing real secrets in Git.
Using Safer Sharing Methods
If multiple developers need the same non production secrets, you can:
- Use a shared secret manager configured for development.
- Use an encrypted password manager shared vault.
- Use encrypted files under version control, for example:
secrets.encin Git, and a separate key out of band.
These are more advanced setups, but the idea is to avoid clear text secrets in your repository.
Avoiding Secret Leaks in Logs and Errors
Even if you store secrets correctly, you can leak them at runtime.
Do Not Log Secrets
Risky code:
print(f"Connecting to database: {DATABASE_URL}")
If DATABASE_URL contains the password, your logs now have it.
Better:
from urllib.parse import urlparse
def safe_db_url(url):
parsed = urlparse(url)
return f"{parsed.scheme}://{parsed.hostname}:{parsed.port}/{parsed.path.lstrip('/')}"
print(f"Connecting to database: {safe_db_url(DATABASE_URL)}")Or log only the database host or name, not credentials.
Be Careful with Error Messages
Avoid revealing secrets in stack traces or error pages.
Example of a bad pattern:
try:
connect_to_db(DATABASE_URL)
except Exception as exc:
raise RuntimeError(f"Failed to connect to {DATABASE_URL}") from excBetter:
try:
connect_to_db(DATABASE_URL)
except Exception as exc:
raise RuntimeError("Failed to connect to database") from excYour logs may still contain internal connection details, so avoid including secret values.
Scanning for Leaked Secrets
Even with good practices, accidents happen. Tools can help you detect secrets in your codebase.
Types of Secret Scanning
- Local pre‑commit hooks that scan your changes before you commit.
- CI tools that scan commits or pull requests.
- Full repository scans to find historic leaks.
Popular tools (conceptual, no need to learn them now):
git-secretstruffleHog- GitHub secret scanning
If you ever discover a secret that has been committed, act as if it is leaked:
- Remove it from the code.
- Rotate the secret.
- Invalidate the old value.
- Consider scanning your entire repository.
Practical Patterns for Small Projects
For small projects or early learning, use patterns that are simple but not careless.
Minimal Reasonable Setup
For a simple FastAPI project:
- Do not put secrets in
.pyfiles. - Create
.envand.env.example:
.env.example:
APP_ENV=local
DATABASE_URL=postgresql://user:password@localhost:5432/app_db
JWT_SECRET=change-me
.env (ignored by Git):
APP_ENV=local
DATABASE_URL=postgresql://user:localpass@localhost:5432/app_db
JWT_SECRET=really-long-random-string- Load
.envin your app:
from dotenv import load_dotenv
import os
load_dotenv()
APP_ENV = os.getenv("APP_ENV", "local")
DATABASE_URL = os.environ["DATABASE_URL"]
JWT_SECRET = os.environ["JWT_SECRET"]- When you deploy, set environment variables through:
- Your hosting provider dashboard.
- Docker Compose environment.
- Kubernetes secrets.
This gives you a clean separation between code and secrets, even on your first backend project.
Summary
- A secret is any value that must be kept confidential, for example passwords, API keys, tokens, and encryption keys.
- Never hard‑code secrets or commit them to version control.
Always externalize secrets, limit their scope, separate environments, and be ready to rotate and revoke them quickly.
- Use environment variables and non tracked files like
.envin development. - For production, prefer a secrets manager or secure environment variable management.
- Manage secrets separately for local, staging, and production.
- Avoid leaking secrets through logs and error messages.
- Use secret scanning tools to catch mistakes.
With these habits your backend will be far more resilient to common security failures that come from poor secrets management.
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!