22.8. TLS Certificates
Table of Contents
Why TLS Certificates Exist
When you visit https://example.com, your browser wants to be sure of two things:
- Your connection is encrypted, so others cannot read or modify the data.
- You are really talking to example.com, not an attacker.
TLS (Transport Layer Security) is the protocol that encrypts traffic.
A TLS certificate is the digital document that proves the server’s identity and helps set up encryption.
A website can only be considered secure if:
- It uses HTTPS (TLS encryption), and
- The TLS certificate is valid, not expired, issued by a trusted authority, and matches the domain.
Without a proper TLS certificate, users see browser warnings like “Your connection is not private.”
Basic Concepts and Terminology
Public Key, Private Key, and Certificates
TLS uses public key cryptography:
| Item | Kept Where | Purpose |
|---|---|---|
| Private key | On the server only | Decrypt data, prove identity |
| Public key | Inside the certificate | Encrypt data, verify signatures |
| Certificate | Sent to clients | Binds public key to a domain or organization |
The certificate is basically:
“The holder of this private key is allowed to use this domain name.”
signed by a Certificate Authority.
If an attacker steals the private key, they can impersonate your site.
So private key protection is critical.
Certificate Authorities (CAs) and Trust
Browsers and operating systems ship with a trust store, a list of trusted CAs.
A Certificate Authority:
- Verifies that you control a domain (and sometimes your organization).
- Issues a certificate signed with its own private key.
- Browsers trust your certificate because they already trust the CA.
Your TLS certificate is trusted only if:
- It is signed by a CA present in the client’s trust store, or
- It chains up to such a CA with valid intermediate certificates.
Types of TLS Certificates
By Identity Level
Domain Validated (DV)
- Validates: You control the domain, such as
example.com. - How: Email to
admin@example.com, DNS record, or HTTP file check. - Shows: Padlock and HTTPS. No visible company name.
- Use: Most APIs and websites. Lets Encrypt issues DV certificates.
Organization Validated (OV)
- Validates: Domain + legal organization details.
- CA checks company registration and ownership.
- Used mainly by corporations and institutions.
Extended Validation (EV)
- Validates: Domain + strict company checks, legal existence, physical presence.
- Historically showed company name in browser UI.
- Used for banks, financial services, etc.
- Modern browsers show less special UI than before, so EV is less common.
For backend APIs, DV is usually enough.
By Domain Coverage
| Type | Example domains covered |
|---|---|
| Single-domain | example.com or api.example.com |
| Wildcard | *.example.com (api.example.com, shop.example.com) |
| Multi-domain (SAN) | example.com, api.example.com, other-site.com |
A wildcard *.example.com does not cover the root example.com itself.
You must explicitly include example.com if you need it.
Certificate Chain and Root Certificates
What Is a Certificate Chain?
A browser does not directly trust your server certificate. It trusts root CAs.
Typical structure:
- Root CA certificate
- Self-signed. Stored in the OS or browser trust store.
- Intermediate CA certificate(s)
- Signed by the root. Used to sign server certificates.
- Server (leaf) certificate
- Your domain’s certificate, signed by an intermediate CA.
On TLS handshake, the server should send:
- The server certificate, and
- All intermediate certificates.
The browser uses these to build a chain up to a trusted root.
If an intermediate is missing, clients may show errors like:
- “Incomplete certificate chain”
- “Unable to get local issuer certificate”
Self-Signed Certificates
A self-signed certificate is signed by its own private key, not by a CA.
- Good for: Local development, internal testing.
- Not trusted by browsers by default.
- To avoid warnings, you would have to add it to the client’s trust store manually.
Use self-signed certs only for:
- Development environments.
- Internal systems where you control the clients and can install the root certificate.
How TLS Handshake Uses Certificates
Here is a simplified view of the TLS handshake with HTTPS:
- Client connects to
https://example.comon port 443. - Client sends supported protocol versions and cipher suites.
- Server responds with:
- Its certificate (with public key),
- Intermediate certificates,
- Chosen cipher suite.
- Client verifies the certificate:
- Signature validates up the chain to a trusted root.
- Not expired.
- Not revoked.
- Domain name matches (
example.com). - If all checks pass, client:
- Creates a random secret key.
- Encrypts it with the server’s public key.
- Sends it to the server.
- Server decrypts it using its private key.
- Both sides now share a session key for fast symmetric encryption.
From this point, the connection is encrypted.
If the certificate is invalid, expired, or does not match the domain, the browser must warn the user.
Users should not ignore these warnings in production environments.
Managing TLS Certificates
Key Files You Will See
On a Linux server with Nginx or similar you typically see:
| File | Contains |
|---|---|
privkey.pem | Private key for your domain |
cert.pem | Server certificate for your domain |
chain.pem | Intermediate certificate(s) |
fullchain.pem | cert.pem + chain.pem concatenated |
Some tools or servers can accept a single file that combines them.
Common Certificate Formats
| Extension | Encoding | Typical use |
|---|---|---|
.pem | Base64 with headers -----BEGIN CERTIFICATE----- | Linux, Nginx, Apache |
.crt | Often same as .pem | Generic cert file |
.key | Private key in PEM format | Server private key |
.pfx / .p12 | Binary PKCS#12 format | Windows, some load balancers, Java key stores |
Converting often uses openssl, for example:
# Convert PFX to PEM (cert + key)
openssl pkcs12 -in cert.pfx -out cert.pem -nodesGetting TLS Certificates
Free Certificates with Let’s Encrypt
Let’s Encrypt is a free, automated CA that issues DV certificates.
Typical flow on a Linux server:
- Install Certbot:
sudo apt update
sudo apt install certbot python3-certbot-nginx- Request a certificate for your domain (Nginx example):
sudo certbot --nginx -d example.com -d www.example.comCertbot:
- Proves domain control by serving a special file over HTTP or using DNS.
- Requests a certificate from Let’s Encrypt.
- Configures Nginx to use the new certificate.
- Sets up automatic renewals via cron or systemd.
Check renewal status:
sudo certbot renew --dry-runPaid Certificates
Some organizations still buy certificates from commercial CAs, for example:
- To get OV or EV certificates.
- To meet specific compliance requirements.
- For special-use cases or support agreements.
The process is similar:
- Generate a CSR (Certificate Signing Request) on the server.
- Submit CSR to the CA.
- Complete domain and / or organization verification.
- Download the certificate and intermediate chain.
- Configure on the server.
CSR generation example:
# generate a private key
openssl genrsa -out example.com.key 2048
# generate a CSR
openssl req -new -key example.com.key -out example.com.csrCertificate Lifetimes, Renewal, and Revocation
Expiration and Renewal
Certificates have a validity period:
- Let’s Encrypt: typically 90 days.
- Many commercial CAs: up to 1 year.
If the expiration date passes, clients will reject the cert.
Always set up automatic renewal for TLS certificates.
An expired certificate is a very common and easily avoidable production outage.
For Let’s Encrypt, Certbot handles:
sudo certbot renewYou still must reload or restart your web server after renewal if the tool does not do it automatically.
For example, with Nginx:
sudo systemctl reload nginxRevocation
If a private key is leaked or a domain is no longer under your control, you must revoke the certificate.
- Revocation tells clients that a certificate should no longer be trusted before it expires.
- CAs publish revocation via:
- CRL (Certificate Revocation Lists),
- OCSP (Online Certificate Status Protocol).
Modern browsers mainly use OCSP or OCSP stapling.
As a backend developer, if you suspect key compromise:
- Generate a new key and CSR.
- Get a new certificate.
- Request revocation of the old certificate from the CA.
Common Certificate Problems and Errors
Common Browser Errors
| Error message (example) | Likely cause |
|---|---|
| “Your connection is not private” | Multiple possible issues |
| “Certificate has expired” | Certificate validity end date passed |
| “Certificate not yet valid” | System time incorrect or wrong notBefore date |
| “Certificate is not trusted” | Unknown CA or missing chain |
| “Hostname mismatch” or “SEC_ERROR_BAD_CERT_DOMAIN” | Cert’s CN/SAN does not match domain |
Check using tools like:
openssl s_client -connect example.com:443 -servername example.comor online services like SSL Labs’ SSL Server Test.
Hostname Mismatch Example
If your certificate is issued for api.example.com and you use it for example.com, browsers will show a domain mismatch error.
Fix: Request a certificate that covers all required hostnames, for example:
example.comwww.example.comapi.example.com
TLS Certificates in Reverse Proxies and Load Balancers
Termination at the Reverse Proxy
In many backend setups:
- Nginx or Traefik is the reverse proxy.
- Uvicorn or Gunicorn serves your Python app.
Typical pattern:
- Client connects to
https://api.example.com:443with TLS. - Nginx terminates TLS using the certificate.
- Nginx forwards traffic to your app over HTTP, for example
http://127.0.0.1:8000.
In this case:
- The TLS certificate and key exist only on the reverse proxy.
- The application server does not need a certificate.
This is called TLS termination or SSL termination at the reverse proxy.
End-to-End Encryption
Sometimes, especially in multi-server or multi-datacenter setups, you want encryption:
- Client to reverse proxy.
- Reverse proxy to backend services.
Then each hop uses its own certificate.
For internal traffic you might:
- Use an internal CA.
- Use self-signed certs, and configure services to trust that CA.
Security Best Practices for TLS Certificates
Strong Keys and Algorithms
- Use at least 2048-bit RSA keys or modern elliptic curve keys (like ECDSA).
- Disable obsolete protocols and ciphers:
- Disable SSLv2, SSLv3, TLS 1.0, TLS 1.1.
- Prefer TLS 1.2 and TLS 1.3.
Nginx example snippet:
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers HIGH:!aNULL:!MD5;Private Key Protection
Never commit private keys to Git or store them in public places.
Limit file permissions to the web server user only.
On Linux:
chown root:root /etc/ssl/private/example.com.key
chmod 600 /etc/ssl/private/example.com.keyHTTP to HTTPS Redirect
Always redirect HTTP to HTTPS so all traffic is encrypted.
Nginx example:
server {
listen 80;
server_name example.com www.example.com;
return 301 https://$host$request_uri;
}HSTS (HTTP Strict Transport Security)
HSTS tells browsers to always use HTTPS for your domain, which helps prevent downgrade attacks.
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
Use with care, especially includeSubDomains, because once enabled for a long max-age it is hard to roll back.
Example: Nginx Configuration Using a TLS Certificate
Assume you have:
- Certificate:
/etc/letsencrypt/live/example.com/fullchain.pem - Private key:
/etc/letsencrypt/live/example.com/privkey.pem - FastAPI app at
http://127.0.0.1:8000
Example Nginx server block:
server {
listen 80;
server_name example.com www.example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
server_name example.com www.example.com;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers HIGH:!aNULL:!MD5;
location / {
proxy_pass http://127.0.0.1:8000;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $remote_addr;
proxy_set_header X-Forwarded-Proto https;
}
}This config shows how your certificate ties into real-world backend deployment.
Summary
- TLS certificates prove a server’s identity and enable encrypted connections.
- They are issued and signed by Certificate Authorities that browsers trust.
- A full certificate chain is required, from server certificate up to a trusted root.
- You can use free DV certificates from Let’s Encrypt, often managed automatically by Certbot.
- Certificates expire and must be renewed; set up automatic renewal.
- Protect private keys and configure your reverse proxy correctly.
- In a typical backend, TLS terminates at the reverse proxy such as Nginx or Traefik, which holds the certificate and forwards traffic to your application server.
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!