24.7. GitLab CI/CD
Table of Contents
GitLab CI/CD
GitLab CI/CD is GitLab's built-in system for running tests, building artifacts, and deploying your backend projects automatically whenever something changes in your repository.
In this chapter you will learn how GitLab CI/CD works, how to configure pipelines with .gitlab-ci.yml, and how to use it specifically for backend projects, especially those that use Docker.
GitLab CI/CD Concepts
GitLab CI/CD has a few core concepts you must understand before you write any configuration.
Key building blocks
| Concept | What it is | Simple example |
|---|---|---|
| Pipeline | A full run of CI/CD that contains multiple stages and jobs | "test, then build, then deploy" |
| Stage | A group of jobs that run in parallel, stages run in order | test stage then build stage |
| Job | A single task that runs in a runner | "run unit tests", "build Docker image" |
| Runner | The machine or container that executes jobs | GitLab shared runner, or your own VM |
| Artifact | Files created by jobs and stored by GitLab for later stages or download | Test reports, coverage, built packages |
| Cache | Temporary storage to speed up jobs, not a permanent artifact | Caching venv, node_modules, or .m2 |
| Environment | A named deployment target | staging, production |
A pipeline is created when a relevant event happens, for example:
- A push to a branch
- A merge request is opened or updated
- A tag is pushed
- A scheduled pipeline runs
The behavior of the pipeline is defined by a single file in the root of your repository: .gitlab-ci.yml.
The .gitlab-ci.yml File
The .gitlab-ci.yml file is the heart of GitLab CI/CD. It is where you define stages, jobs, images, variables, and rules.
Basic structure
A minimal structure usually has:
stages:
- test
- build
- deploy
unit_tests:
stage: test
script:
- echo "Running tests"
build_image:
stage: build
script:
- echo "Building..."
deploy_prod:
stage: deploy
script:
- echo "Deploying..."Indentation and syntax
- YAML uses spaces, not tabs.
- Nested elements must be indented consistently, usually 2 spaces.
- Job names must be unique in the file.
Important rule
If .gitlab-ci.yml is invalid YAML, no pipelines will run at all. Always validate the file before pushing, for example with an online YAML validator or GitLab's built-in CI Lint.
Defining stages
You define the order of stages in a top-level stages list:
stages:
- lint
- test
- build
- deploy
All jobs in the same stage run in parallel, as long as there are available runners. Stages run sequentially: all lint jobs must finish before any test job starts.
If a job fails in a stage, by default the pipeline stops and later stages are skipped.
Jobs, Scripts, and Images
Each job runs in its own isolated environment, usually a container created from a Docker image.
Using Docker images
You can define a default image for all jobs:
image: python:3.11-slim
stages:
- test
tests:
stage: test
script:
- python --versionOr you can set the image per job:
stages:
- test
- build
python_tests:
stage: test
image: python:3.10
script:
- pip install -r requirements.txt
- pytest
build_frontend:
stage: build
image: node:20
script:
- npm ci
- npm run buildThe script section
The script key is a list of shell commands executed in the job. Example for a Python backend project:
tests:
stage: test
script:
- pip install -r requirements.txt
- pytest -q
GitLab automatically runs these commands using the default shell (for example /bin/sh or bash) inside the job's container or runner environment.
Before script and after script
You can define commands that run before or after every job, or for a specific job.
Global:
before_script:
- python --version
- pip install -U pip
after_script:
- echo "Job finished at $(date)"Per job:
tests:
stage: test
before_script:
- pip install -r requirements.txt
script:
- pytest
The global before_script can be overridden or extended in the job.
Using Variables
Variables let you avoid repeating hard-coded values and allow secure handling of secrets.
Types of variables
- YAML-defined variables in
.gitlab-ci.yml:
variables:
PYTHON_VERSION: "3.11"
PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
tests:
image: "python:${PYTHON_VERSION}"
script:
- echo $PIP_CACHE_DIR- Project-level or group-level variables configured in GitLab UI under
Settings > CI/CD > Variables. - Predefined variables that GitLab provides automatically, such as:
| Variable | Meaning |
|----------------------|------------------------------------------|
| $CI_COMMIT_BRANCH | Name of the branch for the current job |
| $CI_COMMIT_TAG | Tag name if pipeline is for a tag |
| $CI_PROJECT_PATH | namespace/project |
| $CI_JOB_STAGE | Current job's stage |
| $CI_PIPELINE_SOURCE| Type of pipeline trigger (push, web, etc.) |
Using variables in scripts
Variables are environment variables in the job:
tests:
stage: test
variables:
ENV: "test"
script:
- echo "Environment is $ENV"
- echo "Branch is $CI_COMMIT_BRANCH"Protecting secrets
Access secrets through GitLab's CI/CD variables rather than hardcoding them.
For example, you can set POSTGRES_PASSWORD in GitLab UI and use:
test_db:
stage: test
script:
- echo "$POSTGRES_PASSWORD" | wc -c # length, do not print secret
Important rule
Never commit secrets into your repository. Always use GitLab CI/CD variables or an external secret manager.
Runners and Execution Environments
A runner is a machine that picks up jobs and executes them. GitLab supports:
- Shared runners, provided by GitLab (available on GitLab.com)
- Specific runners that you install and register for your projects
Types of runners
Common executor types:
| Executor type | How it runs jobs | Typical use case |
|---|---|---|
| Docker | Starts a new container per job | Most common for backend projects |
| Shell | Runs commands directly on the runner machine | Internal networks, custom tools |
| Kubernetes | Runs jobs as pods in a Kubernetes cluster | Larger organizations, cloud native setups |
Choosing an image with Docker executor
When using Docker executor, image is important because it defines the environment. For a Python FastAPI backend:
image: python:3.11-slim
tests:
stage: test
script:
- pip install -r requirements.txt
- pytestFor building Docker images inside CI you typically use an image with Docker CLI or use the GitLab Docker-in-Docker (DinD) service, which we will see later.
Conditional Jobs: only, except, rules
You usually do not want to run every job on every branch. GitLab offers only, except, and rules to control when jobs run.
only and except (older style)
Example:
deploy_prod:
stage: deploy
script:
- ./deploy.sh
only:
- main # only run on main branch
except:
- tags # do not run for tagsYou can also use special keywords:
test_merge_requests:
stage: test
script:
- pytest
only:
- merge_requestsrules (newer, more flexible)
rules gives fine-grained control:
deploy_staging:
stage: deploy
script:
- ./deploy_staging.sh
rules:
- if: '$CI_COMMIT_BRANCH == "develop"'
deploy_prod:
stage: deploy
script:
- ./deploy_prod.sh
rules:
- if: '$CI_COMMIT_BRANCH == "main"'
when: manual # require a button click
rules can check various variables:
test_mr:
stage: test
script:
- pytest
rules:
- if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
Comparison operators in rules use standard equality or inequality. For example:
$CI_COMMIT_BRANCH == "main"$CI_COMMIT_BRANCH != "main"
Artifacts and Cache
Artifacts and cache both store files from jobs, but they are used in different ways.
Artifacts
Artifacts are meant to be passed to later stages or downloaded from the pipeline UI.
Example: Archive test reports or built packages.
tests:
stage: test
script:
- pytest --junitxml=report.xml
artifacts:
paths:
- report.xml
expire_in: 1 weekExample: Use build artifacts in a deploy job.
build_package:
stage: build
script:
- python -m build
artifacts:
paths:
- dist/
deploy:
stage: deploy
needs:
- build_package
script:
- ls dist/
- ./deploy.sh dist/Cache
Cache is intended to speed up jobs by reusing files like dependencies.
Example: Cache Python dependencies:
cache:
key: "$CI_COMMIT_REF_SLUG"
paths:
- .venv/
- .cache/pip/
tests:
stage: test
script:
- python -m venv .venv
- source .venv/bin/activate
- pip install -r requirements.txt
- pytestNote:
cacheis best-effort; it can be pruned or invalidated.- Artifacts are more reliable for passing build outputs between stages.
A common pattern for dependencies is to use a broader key so it can be reused across branches:
cache:
key: "deps"
paths:
- .cache/pip/Example: Simple Python Backend Pipeline
Here is a basic CI setup for a Python backend project with tests and linting.
image: python:3.11-slim
stages:
- lint
- test
variables:
PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
cache:
key: "pip-cache"
paths:
- .cache/pip/
before_script:
- python --version
- pip install -U pip
lint:
stage: lint
script:
- pip install flake8
- flake8 src tests
tests:
stage: test
script:
- pip install -r requirements.txt
- pytest --maxfail=1 --disable-warnings -qHow this works:
lintandtestsuse the same Python image.lintruns first, thentestsbecause of stage order.- The pip cache is shared so the second job installs faster.
Building Docker Images in GitLab CI
Many backend applications are deployed as Docker containers. GitLab CI can build and push images automatically.
Using Docker-in-Docker (DinD)
A common approach is to use Docker-in-Docker with a docker image and a docker:dind service.
image: docker:25
services:
- docker:25-dind
variables:
DOCKER_TLS_CERTDIR: "/certs"
DOCKER_DRIVER: overlay2
stages:
- build
build_image:
stage: build
script:
- docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
- docker build -t "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA" .
- docker push "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA"Here:
$CI_REGISTRY,$CI_REGISTRY_IMAGE,$CI_REGISTRY_USER, and$CI_REGISTRY_PASSWORDare predefined variables in GitLab when using its built-in container registry.- The image is tagged with the commit short SHA, which is unique per commit.
You could also tag by branch or tag name:
script:
- export TAG="${CI_COMMIT_TAG:-$CI_COMMIT_BRANCH}"
- docker build -t "$CI_REGISTRY_IMAGE:$TAG" .
- docker push "$CI_REGISTRY_IMAGE:$TAG"Example: Build and test FastAPI app
stages:
- test
- build
variables:
DOCKER_TLS_CERTDIR: "/certs"
test_app:
stage: test
image: python:3.11-slim
script:
- pip install -r requirements.txt
- pytest
build_image:
stage: build
image: docker:25
services:
- docker:25-dind
script:
- docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
- docker build -t "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA" .
- docker push "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA"
needs:
- test_app
The needs keyword ensures build_image waits for tests and can start as soon as they pass.
Deployments and Environments
GitLab CI/CD can track deployments to environments such as staging and production.
Defining environments
deploy_staging:
stage: deploy
script:
- ./deploy_to_staging.sh
environment:
name: staging
url: https://staging.example.com
rules:
- if: '$CI_COMMIT_BRANCH == "develop"'
deploy_production:
stage: deploy
script:
- ./deploy_to_production.sh
environment:
name: production
url: https://api.example.com
rules:
- if: '$CI_COMMIT_BRANCH == "main"'
when: manualNotes:
- The environment name groups deployments in GitLab's Environments page.
- The URL gives you a link from the pipeline to the environment.
- Marking production deploys as
manualhelps avoid accidental deployments.
Example: Docker-based deployment script
Your deploy_to_production.sh might do something like:
#!/bin/bash
set -e
TAG="$CI_COMMIT_SHORT_SHA"
docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
docker pull "$CI_REGISTRY_IMAGE:$TAG"
docker stop myapp || true
docker rm myapp || true
docker run -d --name myapp \
-p 80:8000 \
-e ENV=production \
"$CI_REGISTRY_IMAGE:$TAG"You would commit this script and call it from the GitLab CI job.
Merge Request Pipelines and Code Quality
CI is especially useful for merge requests, where you want to run tests and checks before merging.
Running pipelines only for merge requests
test_mr:
stage: test
image: python:3.11
script:
- pip install -r requirements.txt
- pytest
rules:
- if: '$CI_PIPELINE_SOURCE == "merge_request_event"'Enforcing passing pipelines
In GitLab project settings you can require merge requests to have green pipelines before merging, which is a common practice for backend teams.
Example: Complete Backend CI/CD Flow
Here is a more complete example for a FastAPI backend with:
- Lint and tests on every branch
- Docker image build on main and develop
- Automatic deploy to staging from develop
- Manual deploy to production from main
image: python:3.11-slim
stages:
- lint
- test
- build
- deploy
variables:
PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
DOCKER_TLS_CERTDIR: "/certs"
cache:
key: "pip-cache"
paths:
- .cache/pip/
before_script:
- python --version
- pip install -U pip
lint:
stage: lint
script:
- pip install flake8
- flake8 app tests
rules:
- if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
- if: '$CI_COMMIT_BRANCH'
tests:
stage: test
script:
- pip install -r requirements.txt
- pytest
artifacts:
reports:
junit: report.xml
rules:
- if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
- if: '$CI_COMMIT_BRANCH'
build_image:
stage: build
image: docker:25
services:
- docker:25-dind
script:
- docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
- export TAG="${CI_COMMIT_SHORT_SHA}"
- docker build -t "$CI_REGISTRY_IMAGE:$TAG" .
- docker push "$CI_REGISTRY_IMAGE:$TAG"
needs:
- tests
rules:
- if: '$CI_COMMIT_BRANCH == "develop"'
- if: '$CI_COMMIT_BRANCH == "main"'
deploy_staging:
stage: deploy
image: alpine:3
environment:
name: staging
url: https://staging.example.com
script:
- apk add --no-cache openssh
- ./deploy_staging.sh
rules:
- if: '$CI_COMMIT_BRANCH == "develop"'
deploy_production:
stage: deploy
image: alpine:3
environment:
name: production
url: https://api.example.com
script:
- apk add --no-cache openssh
- ./deploy_production.sh
rules:
- if: '$CI_COMMIT_BRANCH == "main"'
when: manual
allow_failure: false
You would implement deploy_staging.sh and deploy_production.sh to perform SSH, run Docker commands on servers, or trigger any other deployment mechanism.
Practical Tips and Common Pitfalls
- Validate
.gitlab-ci.ymlusing the CI Lint tool in GitLab (CI/CD > Pipelines > CI Lint). - Use small, focused jobs instead of a single huge job, this gives better feedback and caching.
- Use
rulesfor fine control instead of mixingonlyandexcept. - Do not print secrets in job logs.
- Keep Docker images small, for example use
python:3.11-sliminstead of full images. - Cache dependencies but do not cache build outputs that must be reliable, use artifacts for those.
With this knowledge you can set up GitLab CI/CD for your backend projects, automate testing and builds, and connect it to your deployment process.
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!