• Get started
    • Set up the local development environment
      • 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 project
        • Set up a project in the Cloud
        • About deployment
        • Explore the Dashboard
      • 2. Set up your project locally
        • Build the project locally
        • Install Python and Django using the Dockerfile
        • Create a docker-compose.yml file for convenience
        • Create a new Django project in the application
        • Start the local project
        • Add a start-up instruction to the Dockerfile
        • Local commands
      • 3. Deploy your application to the cloud
      • 4. Add and configure a Postgres database
        • Create the database
        • Configure database access using an environment variable
        • Use the environment variable in our settings
        • Deploy your changes
      • 5. Configure static file serving
      • 6. Add and configure media storage
        • Create the media storage
        • Use the environment variable in our settings
        • Configure local file storage serving
        • Test file storage and serving configuration
      • 7. Apply some refinements
        • Set DEBUG using an environment variable
        • Configure ALLOWED_HOSTS
        • Configure SECRET_KEY
        • Configure SSL redirects
        • Add collectstatic to the build
    • Django with Aldryn
      • 1. Create a new Django project using Aldryn Django
        • About this tutorial
        • Set up a project in the Cloud
        • About deployment
        • Explore the Dashboard
      • 2. Set up your project locally
        • Build the project locally
        • Start the local project
        • Local commands
      • 3. Make changes and deploy them
        • Install a package
        • Run migrations
        • Check the project
        • Deploy to the cloud
        • Using divio project push/pull
      • 4. Configure a more complex application
        • Add django-debug-toolbar to requirements.in
        • Configure settings.py
        • Configure urls.py
        • See the results
        • Where to go next?
    • Wagtail
      • 1. Create a new Wagtail Django project
        • Set up a project in the Cloud
        • About deployment
        • Explore the Dashboard
      • 2. Set up your project locally
        • Build the project locally
        • Start the local project
        • Local commands
      • 3. Make changes and deploy them
        • Add a new home application
        • Deploy to the cloud
        • Using divio project push/pull
        • Install a package from pip
        • More complex configuration
        • Where to go next?
    • PHP/Laravel, using Flavours
      • 1. Create a new PHP/Laravel project
        • Set up a project in the Cloud
        • About deployment
        • Explore the Dashboard
      • 2. Set up your project locally
        • Build the project locally
        • Run the set-up script
        • Start the local project
        • Local commands
      • 3. Make changes and deploy them
        • Make a change
        • Deploy to the Cloud
      • 4. Install an application using Flavours
        • Introducing Flavours
        • Install the Flavours CLI
        • Run the flavour add command
        • Check what the command has done to the project
        • Deploy to the Cloud
        • Explore configuration
        • Where to go next?
  • How-to guides
    • Working in the local development environment
      • Get started with the Divio CLI
        • Pre-requisites
        • Install the CLI
        • Log in using the CLI
        • Add your public key to the Control Panel
        • Usage
      • Run the local server in Live configuration
        • Build the project
        • Isolate the container’s file system from your own
        • Ensure the application runs in a production configuration
        • Run the migrate command
        • Use the cloud media storage rather than local file storage
        • Use the cloud database rather than a local instance
        • Use the production web server
    • Building your Docker application
      • Manage a project's base image
        • Choose a base image
        • Specify the base image in the Dockerfile
        • Caveats
      • Install system packages
    • Platform-specific guides
      • Django
        • Create and deploy a Django project
        • Create a multi-site Django project using Mirrors
        • Go-live checklist for Django projects
      • Python
        • Install Python dependencies
        • Pin all of your project's Python dependencies
      • Django with Aldryn
        • Add a Django application to an Aldryn project
        • Configure Django settings using Aldryn
        • Configure an existing Django project to use Aldryn
        • Configure external logging
        • Configure Celery
        • Manage access authentication
        • Manage redirects in Django projects
        • Log in to a local Django project
        • Manage uWSGI configuration
        • Fine-tune uWSGI server performance
        • Package an application as an Aldryn addon
        • Update an existing Aldryn addon
      • Node.js
        • Force HTTPS with Express.js
    • Managing a project’s resources
      • Interact with your project’s database
        • Interact with the local database
        • Interact with the Cloud database
        • Change the local database engine version
        • Usage examples for common basic operations
      • Interact with your project’s cloud media storage
        • Interact with your project’s cloud S3 storage
        • Use the Divio CLI for local access to Cloud storage
        • Storage ACLs (Access Control Lists)
      • Manage environment variables
        • Reading environment variables
        • Setting environment variables
    • Adding new functionality to a project
      • Set up Sass CSS compilation
        • What we want to do
        • Building this into the Dockerfile
        • Further frontend development
        • Using Boilerplates for quicker project creation
      • Configure Application Performance Monitoring
        • Set up the APM instance
        • Install and configure the Divio Telemetry addon
        • Check the results
      • Configure media serving on a custom domain
        • Set up the reverse proxy project
        • Configure media storage URLs in the application project
        • Caveats
    • The development pipeline
      • Configure external Git hosting
        • Prepare the external Git repository
        • Add the Git repository URL to the Control Panel
        • Add your project’s public key to the Git host
        • Test access
        • Configure a webhook for the Git repository
        • Using the external Git remote
        • Options and special cases
        • Errors and what they mean
      • Use Git to manage your project
        • Important limitations
        • Git with the Divio app or Divio shell
        • Basic Git operations
      • Set up CI/CD
        • The basic principles
        • An example using Travis CI
        • Using the deployment API directly
        • Caveats
      • Use our API
        • Create a Divio account for use with the API
        • Connecting to the API
        • Basic requests
    • Troubleshooting
      • Debug cloud deployment problems
        • Debugging checklist
        • Decision tree
      • 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 project
        • What we can and can’t help with
  • Technical reference
    • Divio software components
      • The Divio application
        • Controls
        • First run
        • The Divio Shell
      • Divio CLI
        • divio-cli command reference
      • The Cloud and local shells
        • Using a Cloud shell
        • The local shell
      • The .aldryn file
      • Divio environment variables
    • Docker commands and configuration
      • Docker commands
        • The docker-compose command
        • The docker command
      • The Dockerfile
        • How the Dockerfile is automatically populated
      • The docker-compose.yml file
        • Function of docker-compose.yml
        • Services defined in docker-compose.yml
        • Further reading
    • Python/Django application configuration
      • The settings.py file
        • INSTALLED_ADDONS
        • Automatic settings loading
    • Coding in Divio applications
      • Working with your project’s media storage
        • Introduction
        • Working with our storage backends in Django
        • Loading media files into your applications’ pages
        • Storage speed and performance
      • File compression
        • Default behaviour in our projects
        • Using Django Compressor
      • Sending email
        • Configuration
        • Usage, testing and troubleshooting
    • Addons
      • Addon configuration with aldryn_config.py
        • The aldryn_config.py file
        • Managing settings
        • Adding form fields for user-configuration of the Addon
        • Custom field validation
        • What configuration method to provide?
      • Aldryn Django (core Django)
        • Control Panel options
        • Environment variable/settings.py options
      • Aldryn SSO (authentication)
        • Login methods
        • Test site protection
        • Aldryn SSO configuration options
      • Aldryn Addons (addon integration)
        • Aldryn Addons configuration options
    • Quick reference
      • Local commands cheatsheet
        • Project resource management
        • Running the local server
        • Working inside the containerised environment
        • Docker management
  • Background information
    • 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 projects
        • Other options
        • IPv6 support
    • Services
      • Service management (Beta)
        • Service management via the Control Panel
      • Available services
        • Database
        • Media object storage
        • Elasticsearch
        • RabbitMQ
    • How it works on Divio
      • HTTP redirects
        • Protocol redirects
        • 301 Permanent vs 302 Temporary redirects
      • Caching and CDN
        • Infrastructure-level caching
        • Application-level caching
      • Python package installation in Aldryn Django projects
        • Selective execution of commands
        • Summary of commands
        • Our wheels proxy
        • Caching
      • Environment variables
        • Cloud (Live and Test) environments
        • Local environment
        • Environment variables and Django settings
        • Where and when environment variables are applied
        • Commonly-used environment variables
    • Projects
      • Project creation options
        • Platform
        • Type
        • Boilerplate
        • Git repository manager
      • Anatomy of a Divio project
        • Dockerfile
        • Local development files
        • Aldryn Addons directories
      • The project deployment process
        • Deployment steps
        • Zero-downtime cloud deployments
        • Differences between cloud deployment and local builds
        • Notes on Docker image building
      • Project environments
        • Default project conditions
      • Version control
        • All commits target the Test environment
        • Project repository branches
        • Custom Tracking Branches
      • Boilerplates
        • Boilerplates
        • Our built-in Boilerplates
        • How Boilerplates work
      • Multi-site projects on Divio
        • Using Mirrors
        • DIY implementation (for Django sites only)
        • Logging in to multi-site instances
        • Switching between sites in a local multi-site project
    • Aldryn Django and addons
      • What is Aldryn, and why use it?
        • What are Aldryn addons?
        • Using Aldryn is optional
        • Why use addons?
      • Anatomy of a Divio addon
        • Basic file structure
        • aldryn_config.py
        • addon.json
        • setup.py
      • How settings are handled in Django addons
        • Via addon settings in the Control Panel
        • Via environment variables
        • Manually in settings.py
      • Django addons and templates
        • On initial project creation
        • Subsequent addon updates
Developer Handbook
Divio
  • Docs  » 
  • Technical reference

Technical reference¶

Divio software components¶

  • The Divio application
  • Divio CLI
  • The Cloud and local shells
  • The .aldryn file
  • Divio environment variables

Docker commands and configuration¶

  • Docker commands
  • The Dockerfile
  • The docker-compose.yml file

Python/Django application configuration¶

  • The settings.py file

Coding in Divio applications¶

  • Working with your project’s media storage
  • File compression
  • Sending email

Addons¶

  • Addon configuration with aldryn_config.py
  • Aldryn Django (core Django)
  • Aldryn SSO (authentication)
  • Aldryn Addons (addon integration)

Quick reference¶

  • Local commands cheatsheet

© Copyright 2017-2020, Divio AG. Revision a31a8599.

Edit on GitHub

Documentation v: latest
Versions
latest
Downloads
pdf
html