6. Introduction to Web Backends

Comments

Please login to add a comment.

Don't have an account? Register now!

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