Divio Documentation

Divio is a multi cloud infrastructure management service, with a platform for containerised web application deployment.

Divio aims to provide a better way to develop, deploy, scale and maintain web applications, and manage the infrastructure they run on, using workflows you’re familiar with and open-source tools you can trust.

Applications deployed on Divio can be created with any stack, platform or language.

They are containerised using Docker, versioned in Git and can be deployed to any one of multiple global cloud regions. Each application is provided with multiple environments (Test, Live, etc), with its own services (database, storage, backups, metrics, logging and more). Services are provisioned automatically for each environment.

For the convenience of developers, Divio includes comprehensive developer tools, and a powerful local development environment.

Quickstart

Python Django Node.js PHP Java Other

Get started

Tutorials. A hands-on introduction to Divio for developers.

Tutorials

How-to

Step-by-step guides. Covers key tasks and operations and common problems.

How-to

Background

Explanation. Clarification and discussion of key topics.

Background

Reference

Technical reference. Covers tools, components, commands and resources.

Reference

 

Additional resources

Community

The Divio Community is there to help you as well.

Join us on Slack     StackOverflow

The Divio API

The Divio API is a powerful tool for interacting with our infrastructure and your applications. See How to use the Divio API in this documentation and the Divio API reference documentation.

Speak to an expert

Do you need to know more about Divio and its capabilities to decide whether the platform is suited to your most complex requirements? Get some answers from an expert, with no obligations and no sales-pitches - just the facts.

Book a short call

Our promises to developers

Divio will help you achieve the results of an entire DevOps team all by yourself - there are just three steps to deployment heaven:

• Docker: containerise your application using the world’s most popular containerisation technology.

• Divio: create an application with the database, storage and other services it will need - all wired up and ready to go.

• Deploy: go live, enjoying a fully automated build and launch.

If you let us take care of the dull, repetitive jobs, you’ll get to do the creative, enjoyable ones.

Index

• Get started
  • Installation
    • Why is the local development environment so important?
    • Before you start
    • Install Docker and Docker Compose
      • Additional checklist for Docker installation on Windows
    • Install the Divio CLI package
    • Log in
    • Add your public SSH key to the Control Panel
    • On to the next step
  • Django
    • 1. Create a new Django application
      • 1.1. Set up a Divio application in the Cloud
        • 1.1.1. Create the application
        • 1.1.2. Application environments
      • 1.2. About deployment
      • 1.3. Explore the Dashboard
        • 1.3.1. Enable Beta options
    • 2. Set up your Divio application locally
      • 2.1. Build the application locally
      • 2.2. Install Python and Django using the Dockerfile
      • 2.3. Create a docker-compose.yml file for convenience
      • 2.4. Create a new Django application in the application
      • 2.5. Start the local application
      • 2.6. Add a start-up instruction to the Dockerfile
      • 2.7. Local commands
        • 2.7.1. Using divio
        • 2.7.2. Using docker
        • 2.7.3. Using docker-compose
    • 3. Deploy your application to the Divio Cloud
    • 4. Add and configure a Postgres database
      • 4.1. Create the database
        • 4.1.1. For the cloud environments
        • 4.1.2. Locally
      • 4.2. Configure database access using an environment variable
      • 4.3. Use the environment variable in our settings
      • 4.4. Deploy your changes
    • 5. Configure static file serving
    • 6. Add and configure media storage
      • 6.1. Create the media storage
        • 6.1.1. For the cloud environments
        • 6.1.2. Locally
      • 6.2. Use the environment variable in our settings
      • 6.3. Configure local file storage serving
      • 6.4. Test file storage and serving configuration
        • 6.4.1. Test local media storage
        • 6.4.2. Test cloud media storage
    • 7. Apply some refinements
      • 7.1. Set DEBUG using an environment variable
      • 7.2. Configure ALLOWED_HOSTS
      • 7.3. Configure SECRET_KEY
      • 7.4. Configure SSL redirects
      • 7.5. Add collectstatic to the build
  • Aldryn
    • 1. Create a new Django application using Aldryn Django
      • 1.1. About this tutorial
      • 1.2. Set up a Divio application in the Cloud
        • 1.2.1. Create the application
        • 1.2.2. Application environments
        • 1.2.3. Deploy the application
        • 1.2.4. Open the Test environment website
      • 1.3. About deployment
      • 1.4. Explore the Dashboard
        • 1.4.1. Enable Beta options
    • 2. Set up your Divio application locally
      • 2.1. Build the application locally
      • 2.2. Start the local application
      • 2.3. Local commands
        • 2.3.1. Using divio
        • 2.3.2. Using docker
        • 2.3.3. Using docker-compose
    • 3. Make changes and deploy them
      • 3.1. Install a package
        • 3.1.1. Configure the Django settings
        • 3.1.2. A brief explanation of Aldryn Addons
      • 3.2. Run migrations
      • 3.3. Check the application
      • 3.4. Deploy to the Divio cloud
      • 3.5. Using divio app push/pull
    • 4. Configure a more complex application
      • 4.1. Add django-debug-toolbar to requirements.in
      • 4.2. Configure settings.py
        • 4.2.1. Configure INSTALLED_APPS
        • 4.2.2. Configure middleware settings
        • 4.2.3. Triggering the toolbar
      • 4.3. Configure urls.py
      • 4.4. See the results
      • 4.5. Where to go next?
  • Wagtail
    • 1. Create a new Wagtail Django application
      • 1.1. Set up a Divio application in the Cloud
        • 1.1.1. Create the application
        • 1.1.2. Application environments
        • 1.1.3. Deploy the application
        • 1.1.4. Open the Test environment website
      • 1.2. About deployment
      • 1.3. Explore the Dashboard
        • 1.3.1. Enable Beta options
    • 2. Set up your Divio application locally
      • 2.1. Build the application locally
      • 2.2. Start the local application
      • 2.3. Local commands
        • 2.3.1. Using divio
        • 2.3.2. Using docker
        • 2.3.3. Using docker-compose
    • 3. Make changes and deploy them
      • 3.1. Add a new home application
        • 3.1.1. Create the application
        • 3.1.2. Configure the Django settings
        • 3.1.3. A brief explanation of Aldryn Addons
        • 3.1.4. Create migrations and migrate the database
        • 3.1.5. Add templates to the application
          • 3.1.5.1. Application-level base.html template
          • 3.1.5.2. Application-level templates
          • 3.1.5.3. Add a page in the Wagtail admin
      • 3.2. Deploy to the cloud
      • 3.3. Using divio app push/pull
      • 3.4. Install a package from pip
        • 3.4.1. Configure the Django settings
        • 3.4.2. Run migrations
        • 3.4.3. Check the application
        • 3.4.4. Deploy again
      • 3.5. More complex configuration
      • 3.6. Where to go next?
  • Laravel
    • 1. Create a new PHP/Laravel application
      • 1.1. Set up a Divio application in the Cloud
        • 1.1.1. Create the application
        • 1.1.2. Application environments
        • 1.1.3. Deploy the application
        • 1.1.4. Open the Test environment website
      • 1.2. About deployment
      • 1.3. Explore the Dashboard
        • 1.3.1. Enable Beta options
    • 2. Set up your Divio application locally
      • 2.1. Build the application locally
      • 2.2. Run the set-up script
      • 2.3. Start the local application
      • 2.4. Local commands
        • 2.4.1. Using divio
        • 2.4.2. Using docker
        • 2.4.3. Using docker-compose
    • 3. Make changes and deploy them
      • 3.1. Make a change
      • 3.2. Deploy to the Divio Cloud
        • 3.2.1. Push your code
        • 3.2.2. Push the database
    • 4. Install an application using Flavours
      • 4.1. Introducing Flavours
      • 4.2. Install the Flavours CLI
      • 4.3. Run the flavour add command
        • 4.3.1. About the command
      • 4.4. Check what the command has done to the application
      • 4.5. Deploy to the Cloud
      • 4.6. Explore configuration
      • 4.7. Where to go next?
• How-to guides
  • Get help and support
    • Documentation
      • For Divio platform users
      • For developers
    • Community support channels
  • Manage your account
    • Update billing and credit card information
    • Retrieve your invoices
    • Upload your SSH public key
      • If you need to create an SSH key
    • Enable Beta features
    • Delete your account
    • Rename an organisation
  • Manage your applications
    • Duplicate an application
      • Select your duplication option
        • Duplication types
          • Fork
          • Mirror
      • Select subscription options
    • Delete an application
    • Add a collaborator
      • Collaborator types
      • Add a collaborator to an organisation
      • Add a collaborator to an application
      • Remove collaborators
    • Rename an application
    • Transfer an application to another organisation
    • Use our backup system
      • How to create backups
      • How to work with existing backups
        • The Restore option
        • The Download option
    • Clear the Cloudflare cache
  • Configure an existing web application for deployment
    • Configure an application (generic guide)
      • Prerequisites
      • The Dockerfile - define how to build the application
        • Install system-level dependencies
        • WORKDIR
        • Install application-level dependencies
        • File-building operations
        • EXPOSE and CMD
        • Access to environment and services
      • Configuring your application
        • Helper modules
        • Security settings
        • Database
        • Static files
        • Media
        • Other values
      • Local container orchestration with docker-compose.yml
        • Local configuration using .env-local
        • Building and running
          • Build with Docker
          • Check the local site
      • Git
      • Deployment
    • Configure a Django application
      • Prerequisites
        • If you don’t already have a working Django application
      • The Dockerfile - define how to build the application
        • Install system-level dependencies
        • WORKDIR
        • Install application-level dependencies
        • File-building operations
        • EXPOSE and CMD
        • Access to environment and services
      • Configuring your application
        • Helper modules
        • Security settings
        • Database
        • Static files
        • Media
        • Other values
        • Add a URL pattern for serving media files in local development
      • Local container orchestration with docker-compose.yml
        • Local configuration using .env-local
        • Building and running
          • Build with Docker
          • Run database migrations if required
          • Check the local site
      • Git
      • Additional notes
      • Deployment
    • Configure a Flask application
      • Prerequisites
      • The Dockerfile - define how to build the application
        • Install system-level dependencies
        • WORKDIR
        • Install application-level dependencies
        • File-building operations
        • EXPOSE and CMD
        • Access to environment and services
      • Configuring your application
        • Helper modules
        • Security settings
        • Database
        • Static files
        • Media
        • Other values
      • Local container orchestration with docker-compose.yml
        • Local configuration using .env-local
        • Building and running
          • Build with Docker
          • Check the local site
      • Git
      • Deployment
    • Configure a Gatsby application
      • Prerequisites
        • If you don’t already have a working Gatsby application
      • The Dockerfile - define how to build the application
        • Install system-level dependencies
        • WORKDIR
        • Install application-level dependencies
        • File-building operations
        • EXPOSE and CMD
        • Access to environment and services
      • Configuring your application
        • Helper modules
        • Security settings
        • Database
        • Static files
        • Media
        • Other values
      • Local container orchestration with docker-compose.yml
        • Local configuration using .env-local
        • Building and running
          • Build with Docker
          • Building on the host as an option
          • Check the local site
      • Git
      • Deployment
  • Create a new application
    • Start a Django application
      • Clone the repository
        • Renaming the quickstart application module (optional)
        • Using MySQL or an alternative gateway server
      • Run the application locally
        • Build the Docker image
        • Run database migrations and create a superuser
        • Launch the local server
      • Additional notes
      • Deployment
    • Start a django CMS application
      • Clone the repository
        • Removing optional components
        • Renaming the quickstart application module (optional)
        • Using MySQL or an alternative gateway server
      • Run the application locally
        • Build the Docker image
        • Run database migrations and create a superuser
        • Launch the local server
      • Additional notes
      • Deployment
    • Start a Gatsby application
      • Clone the repository
      • Run the application locally
        • Build the Docker image
        • Launch the local server
      • Customisation and further development
        • Building on the host as an option
      • Deployment
    • Start a PHP Laravel application
      • Clone the repository
      • Run the application locally
        • Build the Docker image
        • Run database migrations
        • Launch the local server
        • Mapping /app to the local host filesystem
        • Launching the local server with Nginx
      • Deployment
  • Deploy an application
    • Deploy your application to the Divio cloud platform
      • Create a new application on Divio
        • Creating a new application
        • Importing an application from a Git repository
      • Connect your local application to the cloud application
        • Configure Git (if required)
      • Add database and media services
      • Add release commands
      • Add additional environment variables
      • Push local database/media content
      • Push your code
      • Deploy the Test server
    • Go-live checklist
      • Check your subscription plan
      • Dependencies
      • Turn off development mode
      • Domains
      • HTTPS
      • Environment variables
      • File serving configuration
      • Other settings
      • Local tests
      • Deployment
      • After deployment
  • Development workflow
    • Set up the Divio local development environment
      • Pre-requisites
      • Install the CLI
      • Log in using the CLI
      • Add your public key to the Control Panel
      • Usage
      • Next steps for new users
    • Run a local application in live configuration
      • Isolate the container’s file system from your own
      • Ensure the application runs in a production configuration
      • Run the release commands
      • Use the cloud media storage rather than local file storage
      • Using the cloud database rather than a local instance
      • Use the production web server
      • Other configuration
    • Configure external Git hosting
      • Prepare the external Git repository
        • Creating a new Divio application
        • Migrating an existing Divio application
      • Add the Git repository URL to the Control Panel
        • Creating a new Divio application
        • Migrating an existing Divio application
      • Add your application’s public key to the Git host
        • GitHub
        • GitLab
        • BitBucket
      • Test access
      • Configure a webhook for the Git repository (recommended)
        • GitHub
        • GitLab
        • BitBucket
      • Using the external Git remote
      • Remote Git: Reset to origin
      • Options and special cases
        • Read-only access to the repository
        • HTTPS authentication
      • Errors and what they mean
        • The remote repository requires a branch
        • Authentication error
        • The Control Panel not being able to accept the repository URL (the branch)
        • You have no webhook set up
    • Use Git to manage your application
      • Important limitations
        • Git repository contents
      • Git repository size
      • Basic Git operations
        • Push your changes to the Cloud
        • Pull changes from the Cloud
    • Set up CI/CD
      • The basic principles
      • An example using Travis CI
        • Connect your application to the CI service
        • Triggering the deployment on success
          • Authentication
      • Using the deployment API directly
      • Caveats
    • Use the Divio API
      • Create an API-only account
      • Connecting to the API
        • Authentication
      • Basic requests
      • Example
  • Building a Docker application
    • Manage an application's base image
      • Specify the base image in the Dockerfile
      • Choosing an appropriate base image
        • Pin images to a particular version
        • Check included components
      • Base images provided by Divio
        • Manually upgrading Divio base applications
    • Install system packages
  • Platform-specific guides
    • Install Python dependencies
      • pip install and requirements.txt
      • Pin all dependencies
        • With pip
        • Other tools
      • Python package installation in Aldryn Django applications
        • Pinning dependencies in an Aldryn application
          • Compile requirements.txt
          • Amend the Dockerfile
      • Specifying packages via a URL
    • Create a multi-site Django application using Mirrors
      • Create the mirrors
      • Apply environment variables to each mirror
        • Database and media storage
        • SITE_ID
      • Deploy your mirrors
      • Managing database migrations
        • Backwards-compatible migrations
    • Configure Celery
      • Add a Celery service to your application
      • Application configuration
        • Using the broker environment variable
          • For applications using Aldryn Celery
        • Starting the cloud containers
          • For applications using Aldryn Celery
      • Configure Celery for the local environment
        • RabbitMQ
        • Celery worker
        • Celery beat
        • Celery cam
        • The web service
        • Set up local environment variables
      • Run the local application
      • Environment variables
        • For applications using Aldryn Celery
      • Aldryn Celery (legacy)
    • Force HTTPS with Express.js
      • Working locally
    • Add a Django application to an Aldryn application
      • Make the package available to the application
      • Configure the application
        • Configure settings
          • Ordering of settings lists
        • Configure URLs
      • Migrate the database
      • Deploy the application
        • Push your changes
        • Deploy the Test server
    • Configure Django settings using Aldryn
      • Inserting an item at a particular position
      • Manipulating more complex settings
      • Listing applied settings
    • Configure external logging
      • Example using LogDNA
        • Install the logdna Python library
        • Amend the LOGGING configuration
      • Other logging options
        • Sentry
    • Manage access authentication
      • Require login
      • Basic access authentication
    • Manage redirects in Django applications
      • Protocol redirects
      • Domain name redirects
      • Language redirects
      • Permanent redirects
    • Log in to a local Django application
    • Manage uWSGI configuration
      • uWSGI environment variables
        • uWSGI buffer size
      • More complex configuration
    • Fine-tune uWSGI server performance
      • Monitoring and profiling
      • Aldryn Django settings
        • Increase DJANGO_WEB_WORKERS
        • Increase or decrease DJANGO_WEB_MAX_REQUESTS
        • Decrease DJANGO_WEB_TIMEOUT
        • Disable or reconfigure UWSGI_CHEAPER (uWSGI cheaper mode)
    • Package an application as an Aldryn addon
      • Register the addon
      • Add the packaging files
        • The setup.py file
          • If your addon installs an application
          • If your addon contains an application
        • The __init__.py file
          • For an addon that installs a package
          • For an addon that includes a package
        • The other packaging files
      • Add configuration
        • Create aldryn_config.py
        • Provide form-based configuration
        • Provide URL configuration
      • Check the addon
        • Test it
        • Validate it
      • Upload the addon
    • Update an existing Aldryn addon
      • Choose a local application to work with
      • Uninstall the addon locally if necessary
      • Clone the addon repository to addons-dev
      • Run divio app develop
      • Work on the code
      • Push your changes
      • Upload the new addon version
      • Test it on the Control Panel
      • Place the new version in the appropriate channel
  • Managing an application’s resources
    • Interact with your application’s database
      • Interact with the local database
        • From the application’s local Django web container
          • Using dbshell
          • Connecting to a Postgres database manually
            • Using docker exec
        • From your host environment
          • Expose the database’s port to the host
          • Connect to a Postgres database
      • Interact with the Cloud database
        • From the Cloud application’s container
          • Using dbshell in a Django application
          • Connecting to a database manually
        • From your own computer
      • Change the local database engine version
      • Manage Postgres extensions
      • Usage examples for common basic operations
        • Dump the database
        • Drop the database
        • Create the database
        • Apply the hstore extension
        • Restore the database
        • Reset the database
        • Restore from a downloaded Cloud backup
    • Interact with your application’s cloud media storage
      • Direct access to cloud storage
        • Obtaining your cloud storage access credentials
        • Install the client
        • Parse the storage DSN
        • Using the client
      • Use the Divio CLI for local access to Cloud storage
        • Pushing and pulling media files
        • Limitations
      • Configuring S3 buckets
        • Storage ACLs (Access Control Lists)
        • Enable CORS
    • Configure media serving on a custom domain
      • Set up the reverse proxy application
        • Set up a domain for media files
        • Configure Nginx as a reverse proxy
      • Configure media storage URLs in the application application
      • Caveats
    • How to manage your application’s environment variables
      • Using the Divio CLI
      • Using the Control Panel
      • Using a terminal session in a cloud container
      • In the local environment
      • In the build phase
    • Additional information
      • The PORT environment variable
      • Leading and trailing spaces
    • Upgrade a PostgreSQL service
      • Manual upgrade steps
      • Risks
  • Troubleshooting
    • Debug cloud deployment problems
      • Debugging checklist
        • Start here: a deployment has not worked as expected
        • The Control Panel shows a Last deployment failed message
        • Probable fault: temporary problem
        • The deployment log contains no obvious error
        • The runtime log contains no errors
        • The runtime log contains errors
        • The deployment log contains an error
        • Client application error: unable to connect to the application
        • Could not find a version that matches [...]
        • npm ERR! [...] ERR! /npm-debug.log
        • ReadTimeoutError
        • The environment does not show a “Last deployment failed” error
      • Decision tree
    • Diagnose performance issues
      • Action without information is useless
      • Use Application Performance Monitoring
      • Use other tools
        • Metrics
        • Runtime logs
          • Debug tools
    • Identify and resolve a Python dependency conflict
      • Identify the conflict
      • Identify the problem requirement
      • Identify where the requirement comes from
      • Repeat the process
      • How to prevent this from happening again
    • Get help when you have a problem
      • Grant support access
      • Provide key information
      • Template
      • Example report
      • Ensure that we have access to your application
      • What we can and can’t help with
• Technical reference
  • Divio software components
    • Divio CLI
      • Divio CLI configuration
      • Location of the file
      • File structure
      • Using skip_doctor_checks
      • Divio CLI command reference
        • divio
          • addon
            • register
            • upload
            • validate
          • app
            • configure
            • dashboard
            • deploy
            • deploy-log
            • deployments
              • get
              • get-var
              • list
            • develop
            • down
            • environment-variables
              • get
              • list
            • export
              • db
            • import
              • db
            • list
            • logs
            • open
            • pull
              • db
              • media
            • push
              • db
              • media
            • setup
            • ssh
            • status
            • up
            • update
          • boilerplate
            • upload
            • validate
          • doctor
          • login
          • version
    • Divio API reference
    • The cloud and local shells
      • Using a cloud shell
        • The cloud shell instance
      • The local shell
        • Open the shell
    • Divio environment variables
  • Divio infrastructure
    • Checks, limits and timeouts on the Divio platform
      • Deployment health-checks
      • Run-time limits
        • Request timeouts
        • Request sizes
        • Other limits
      • Operations
        • Divio CLI database and media push and pull
  • Docker configuration
    • The Dockerfile
    • The docker-compose.yml file
      • Function of docker-compose.yml
      • Services defined in docker-compose.yml
        • The application container service, web
          • The volumes directive
          • Environment variables
        • The database container service, database_default
      • Further reading
  • Coding in Divio applications
    • Working with your application’s media storage
      • Introduction
      • Working with our storage backends in Django
        • Use Django’s defined DEFAULT_FILE_STORAGE, not FileSystemStorage
          • File storage in third-party applications
        • Private file storage
      • Loading media files into your applications’ pages
        • Load media from static
        • Enable CORS headers
      • Storage speed and performance
    • Working with your application’s database
      • Introduction
      • MySQL on AWS
    • File compression
      • Default behaviour in our applications
        • Using DISABLE_GZIP
        • Using DEBUG = True
      • Using Django Compressor
    • Sending email
  • Applications
    • Divio application backups
      • What’s backed up?
      • Backup storage
      • Scheduled and on-demand backups
      • Retention policies
        • On-demand backups
        • Scheduled backups
    • Zero-downtime deployment
    • Multi-site applications
    • Mirrors
      • Find out how mirrors can make a difference to your business
      • White-label applications
      • Multisite applications
      • Development workflows
    • Application development support
  • Policies
    • How we use terms
      • Applications
      • Regions
      • Services
      • Divio components
        • Control Panel
        • Application builders
        • Application controllers
        • Application runners
        • Ingress controllers
    • Security
      • Technology
        • Python
        • Django
          • Pre-public Django security patches
        • Divio architecture
        • Divio security monitoring
        • Third-party services
        • Security options for Divio users
        • Containerisation
        • Backups
        • Clock synchronization
      • Policies
        • General code security and integrity
        • Staff security policy
        • Incident response plan
        • Security report handling
        • Security testing
      • Standards
        • GDPR
    • Resource usage
      • Soft limits
      • CDN and transfer volume calculations
    • Leaving Divio
      • Licensing conditions
      • Redeployment elsewhere
  • Plans and pricing
    • The Developer plan
      • Developer plan limitations
    • Invoice-based billing
  • Quick reference
    • Divio’s local commands cheatsheet
      • Application resource management
      • Running the local server
      • Working inside the containerised environment
      • Docker management
    • Control panel permissions reference
      • Addons
      • Boilerplates
      • Applications
  • Aldryn Django addons (legacy)
    • Addon configuration with aldryn_config.py
      • The aldryn_config.py file
      • Managing settings
        • Managing URL configuration
      • Adding form fields for user-configuration of the Addon
      • Custom field validation
      • What configuration method to provide?
    • settings.py in Aldryn Django
      • INSTALLED_ADDONS
      • Automatic settings loading
    • Key addons
      • Aldryn Django (core Django)
        • Control Panel options
          • Hash static file names
          • Enable django.contrib.gis
          • Remove URL language prefix for default language
          • Timeout for users session, in seconds
        • Environment variable/settings.py options
          • Security-related settings
            • Security middleware settings
            • Session middleware settings
          • Site-related settings
          • DOMAIN_REDIRECTS
          • ALDRYN_SITES_REDIRECT_PERMANENT
          • Storage settings
            • Cache control for static files
              • STATICFILES_DEFAULT_MAX_AGE
              • DISABLE_S3_MEDIA_HEADERS_UPDATE
          • Django server settings
          • Email settings
          • Miscellaneous settings
      • Aldryn SSO (authentication)
        • Login methods
          • 1. Local development login
          • 2. Django’s standard username/password login form
          • 3. Divio single-sign-on
        • Test site protection
        • Aldryn SSO configuration options
          • ALDRYN_SSO_ALWAYS_REQUIRE_LOGIN
          • ALDRYN_SSO_ENABLE_LOCALDEV
          • ALDRYN_SSO_ENABLE_SSO_LOGIN
          • ALDRYN_SSO_ENABLE_LOGIN_FORM
          • ALDRYN_SSO_ENABLE_AUTO_SSO_LOGIN
          • ALDRYN_SSO_HIDE_USER_MANAGEMENT
          • Basic access authentication
          • SSO_DSN
          • LOGIN_REDIRECT_URL
          • ALDRYN_SSO_LOGIN_WHITE_LIST
          • ALDRYN_SSO_OVERIDE_ADMIN_LOGIN_VIEW
      • Aldryn Addons (addon integration)
        • Aldryn Addons configuration options
          • Addon URLs
            • ADDON_URLS and ADDON_URLS_I18N
            • ADDON_URLS_LAST and ADDON_URLS_I18N_LAST
• Background information
  • Cloud management
    • Environments
      • The Live environment
      • Adding and removing environments (Beta)
    • Metrics (Beta)
      • Memory usage
      • CPU usage
    • Domains
      • DNS records
      • SSL certificates
        • Domain settings and environment variables
        • Redirects
      • Protocol redirects
      • 301 Permanent vs 302 Temporary redirects
    • Service management (Beta)
      • Environment variables
      • Service management via the Control Panel
        • Adding and attaching
        • Detaching and removing
        • States
      • Available services
        • Database
        • Media object storage
        • Elasticsearch
        • RabbitMQ
    • Release commands (Beta)
      • What are release commands?
      • Applying release commands
      • Cautions
        • Risk of failed automated commands
        • Timeouts
      • Failures
  • Our infrastructure
    • Overview
      • Cloud infrastructure
      • Local development environment
    • Docker basics
      • Docker on Macintosh and Windows
      • Key components
      • Glossary
    • IP addresses
      • Load-balancer IP addresses
      • Implications for customer applications
      • Other options
      • IPv6 support
    • Cron jobs
      • Creating tasks
        • Cron commands
      • Cron job timeouts
      • Logging
    • Maintenance operations
      • Maintenance windows
      • Cloudshift region migration
    • Our Python wheels proxy
      • Python wheels
      • The wheels proxy in Aldryn Django applications
        • Summary of commands
        • Typical issues when installing wheels
          • Bad request for URL (from from pip-reqs resolve)
          • A dependency cannot be found (from pip-reqs compile)
          • A wheel cannot be built (from pip-reqs resolve)
          • A wheel cannot be installed (from pip install)
    • Elasticsearch instances
      • Access credentials
      • Access limitations
  • How it works on Divio
    • Caching and CDN
      • Infrastructure-level caching
        • Media storage caching
          • Controlling caching headers
            • In Aldryn Django (legacy)
        • Application content caching
        • Applying your own caching/CDN
      • In-application caching
        • Application caching options
          • What not to use in your code
        • Database caching
        • Third-party caching backends
          • Caching with Aldryn Django (legacy)
    • Configuration using environment variables
      • Cloud environments
        • Via the command line
        • Via the Control Panel
      • Local environment
      • Where and when environment variables are applied
      • Environment variables with Aldryn (legacy)
    • SSL certificates and HTTPS
      • Renewal
      • Custom certificates
      • HTTPS redirects
  • Applications
    • Application creation options
      • Stack
      • Additional components
      • Additional Boilerplate
      • Git repository manager
      • About pre-built application templates
    • The deployment process
      • Deployment steps
        • 1. Services check
        • 2. Git check out
        • 3. Build stage
        • 4. Release commands
        • 5. Scaling
      • Zero-downtime cloud deployments
      • Differences between cloud deployment and local builds
      • Notes on Docker image building
        • Docker image/layer caching and re-use
          • Cloud deployments
          • Image re-use on the cloud
          • Local builds
    • Application environments
      • Default application conditions
    • Version control
      • All commits target the Test environment
      • Application repository branches
      • Custom Tracking Branches
    • Boilerplates
      • Boilerplates
      • Divio’s built-in Boilerplates
        • Blank Boilerplate
        • HTML5 Boilerplate
        • Bootstrap and Foundation Boilerplates
        • Sass Boilerplate
        • Webpack Boilerplate
  • Recommended application configurations
    • Working with our recommended Django application configuration
      • Application container
      • Django server
      • Database
      • Security settings
        • Debug mode
        • Secret key
        • Allowed hosts
        • SECURE_SSL_REDIRECT
      • Static files
      • Media files
      • Database migrations
    • Why should you pin your Python packages in the requirements.txt file?
  • Aldryn Django and addons (legacy)
    • What is Aldryn?
    • Addons
    • About Aldryn (legacy)
      • What are Aldryn addons?
      • The Dockerfile in Aldryn Django applications
        • The empty Dockerfile at application creation
        • The <WARNING> section
        • The <DOCKER_FROM> section
        • The <NODE> section
        • The <NPM> section
        • The <BOWER> section
        • The <PYTHON> section
        • The <SOURCE> section
        • The <GULP> section
        • The <STATIC> section
    • Working with Django addons (legacy)
      • Via addon settings in the Control Panel
      • Via environment variables
        • Via automatically applied environment variables
        • Via user-configured environment variables
      • Manually in settings.py
        • Overwriting automatically-configured settings
      • Anatomy of a Divio addon
        • Basic file structure
        • aldryn_config.py
        • addon.json
        • setup.py
        • Django addons and templates
          • On initial application creation
          • Subsequent addon updates
    • Addons list
      • Supported Addons
      • Unsupported/deprecated Addons
      • Addons Maintained by the Django CMS Association