[Django]-How to automate createsuperuser on django?

As of Django 3.0 you can use default createsuperuser --noinput command and set all required fields (including password) as environment variables DJANGO_SUPERUSER_PASSWORD, DJANGO_SUPERUSER_USERNAME, DJANGO_SUPERUSER_EMAIL for example. --noinput flag is required.

This comes from the original docs: https://docs.djangoproject.com/en/3.0/ref/django-admin/#django-admin-createsuperuser

It is the most convenient way to add createsuperuser to scripts and pipelines.

If you reference User directly, your code will not work in projects where the AUTH_USER_MODEL setting has been changed to a different user model. A more generic way to create the user would be:

echo "from django.contrib.auth import get_user_model; User = get_user_model(); User.objects.create_superuser('admin', 'admin@myproject.com', 'password')" | python manage.py shell

ORIGINAL ANSWER

Here there is a simple version of the script to create a superuser:

echo "from django.contrib.auth.models import User; User.objects.create_superuser('admin', 'admin@example.com', 'pass')" | python manage.py shell

I use ‘./manage.py shell -c’:

./manage.py shell -c "from django.contrib.auth.models import User; User.objects.create_superuser('admin', 'admin@example.com', 'adminpass')"

This doesn’t uses an extra echo, this has the benefit that you can pass it to a docker container for execution. Without the need to use sh -c "…" which gets you into quote escaping hell.

And remember that first comes username, then the email.

If you have a custom user model you need to import that and not auth.models.User

I was searching for an answer to this myself. I decided to create a Django command which extends the base createsuperuser command (GitHub):

from django.contrib.auth.management.commands import createsuperuser
from django.core.management import CommandError


class Command(createsuperuser.Command):
    help = 'Crate a superuser, and allow password to be provided'

    def add_arguments(self, parser):
        super(Command, self).add_arguments(parser)
        parser.add_argument(
            '--password', dest='password', default=None,
            help='Specifies the password for the superuser.',
        )

    def handle(self, *args, **options):
        password = options.get('password')
        username = options.get('username')
        database = options.get('database')

        if password and not username:
            raise CommandError("--username is required if specifying --password")

        super(Command, self).handle(*args, **options)

        if password:
            user = self.UserModel._default_manager.db_manager(database).get(username=username)
            user.set_password(password)
            user.save()

Example use:

./manage.py createsuperuser2 --username test1 --password 123321 --noinput --email 'blank@email.com'

This has the advantage of still supporting the default command use, while also allowing non-interactive use for specifying a password.

I would suggest running a Data Migration, so when migrations are applied to the project, a superuser is created as part of the migrations. The username and password can be setup as environment variables. This is also useful when running an app in a container (see this thread as an example)

Your data migration would then look like this:

import os
from django.db import migrations

class Migration(migrations.Migration):
    dependencies = [
        ('<your_app>', '<previous_migration>'),
    ] # can also be emtpy if it's your first migration

    def generate_superuser(apps, schema_editor):
        from django.contrib.auth.models import User

        DJANGO_SU_NAME = os.environ.get('DJANGO_SU_NAME')
        DJANGO_SU_EMAIL = os.environ.get('DJANGO_SU_EMAIL')
        DJANGO_SU_PASSWORD = os.environ.get('DJANGO_SU_PASSWORD')

        superuser = User.objects.create_superuser(
            username=DJANGO_SU_NAME,
            email=DJANGO_SU_EMAIL,
            password=DJANGO_SU_PASSWORD)

        superuser.save()

    operations = [
        migrations.RunPython(generate_superuser),
    ]

Hope that helps!

EDIT:
Some might raise the question how to set these environment variables and make Django aware of them. There are a lot of ways and it’s been answered in other SO posts, but just as a quick pointer, creating a .env file is a good idea. You could then use the python-dotenv package, but if you have setup a virtual environment with pipenv, it will automatically set the envvars in your .env file. Likewise, running your app via docker-compose can read in your .env file.

DJANGO_SUPERUSER_USERNAME=testuser \
DJANGO_SUPERUSER_PASSWORD=testpass \
DJANGO_SUPERUSER_EMAIL="admin@admin.com" \
python manage.py createsuperuser --noinput

Documentation for the createuser command

You could write a simple python script to handle the automation of superuser creation. The User model is just a normal Django model, so you’d follow the normal process of writing a stand-alone Django script. Ex:

import django
django.setup()

from django.contrib.auth.models import User

u = User(username='unique_fellow')
u.set_password('a_very_cryptic_password')
u.is_superuser = True
u.is_staff = True
u.save()

You can also pass createsuperuser a few options, namely --noinput and --username, which would let you automatically create new superusers, but they would not be able to login until you set a password for them.

Current most voted answer:

• Deletes the user if it exists and as noted by @Groady in the comments you risk unintentionally deleting any associated records via a cascade delete.
• Checks superuser existence filtering by mail so if two superusers have the same mail god knows which one it deletes.
• It is cumbersome to update the script parameters: username, password, and mail.
• Does not log what it did.

An improved version would be:

USER="admin"
PASS="super_password"
MAIL="admin@mail.com"
script="
from django.contrib.auth.models import User;

username = '$USER';
password = '$PASS';
email = '$MAIL';

if User.objects.filter(username=username).count()==0:
    User.objects.create_superuser(username, email, password);
    print('Superuser created.');
else:
    print('Superuser creation skipped.');
"
printf "$script" | python manage.py shell

A solution based on Adam Charnock‘s approach above is available as a Python package by now. It takes three steps:

1. Install: pip install django-createsuperuserwithpassword

2. Activate: INSTALLED_APPS += ("django_createsuperuserwithpassword", )

3. Apply:

    python manage.py createsuperuserwithpassword \
            --username admin \
            --password admin \
            --email admin@example.org \
            --preserve
   

That’s it.

PS: I’m the author of django-createsuperuserwithpassword.

I solved this problem like this.

wsgi.py file always runs when django project starts. So I run create super user commands in here if it doesn’t exist.

import os

from django.contrib.auth.models import User
from django.core.wsgi import get_wsgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', {settings_file})

application = get_wsgi_application()

users = User.objects.all()
if not users:
    User.objects.create_superuser(username="username", email="user@example.com", password="password", is_active=True, is_staff=True)

A function can be added here. For example; if this "user1" doesn’t exist, add "user1".

from django.core.management.base import BaseCommand, CommandError
from django.contrib.auth.models import User

class Command(BaseCommand):

    def handle(self, *args, **options):

        # The magic line
        User.objects.create_user(username= 'rmx',
                                email='superuser@super.com',
                                password='rmx55',
                                is_staff=True,
                                is_active=True,
                                is_superuser=True
        )

I like to use for serverless/docker builds the AppConfig.ready method/event to perform this kind of operations, here’s an example:

import logging

from django.apps import AppConfig
from django.contrib.auth import get_user_model
from django.utils.translation import gettext_lazy as gettext


class Config(AppConfig):
    name: str = "apps.policy"
    label: str = "policy"
    verbose_name: str = gettext("Policies")

    @classmethod
    def ready(cls):
        user_model = get_user_model()
        log = logging.getLogger(cls.label)

        try:
            if not user_model.objects.filter(username="admin").first():
                log.info("Creating default superuser with user and password: admin")
                user_model.objects.create_superuser('admin', 'admin@admin.admin', 'admin')
        except Exception:
            log.warn(
                "Found an error trying to create the superuser, if you aren't"
                "run the user model migration yet, ignore this message"
            )

And when I first start my project in the database I see:

2021-06-22 06:19:02 policy/info  Creating default superuser with user and password: admin
Performing system checks...

System check identified no issues (1 silenced).
June 22, 2021 - 06:19:02
Django version 3.1.12, using settings 'settings.env.default'
Starting development server at http://0.0.0.0:8027/
Quit the server with CONTROL-C.

With shell_plus it’s much easier actually

echo "User.objects.create_superuser('test@test.com', 'test')" | python manage.py shell_plus

As others mentioned, with Django 3.0 you can pass the credentials via environment variables. However this approach is much more flexible since it allows you to do any other more complicated task like removing all tests users, etc.

I used Tk421 one liner but got an error message as: 1) I think I am using a later version of Django (1.10) Manager isn't available; 'auth.User' has been swapped for 'users.User' 2) the order of the parameters to create_superuser was wrong.

So I replaced it with:

echo "from django.contrib.auth import get_user_model; User = get_user_model(); User.objects.filter(email='admin@example.com', is_superuser=True).delete(); User.objects.create_superuser('admin', 'admin@example.com', 'nimda')" | python manage.py shell

and what I as really pleased with is that it works on a heroku deployment as well:

heroku run echo "from django.contrib.auth import get_user_model; User = get_user_model(); User.objects.filter(email='admin@example.com', is_superuser=True).delete(); User.objects.create_superuser('admin', 'admin@example.com', 'nimda')" | python manage.py shell

This will work nicely repeatedly. I am using it the beginning of a project so don’t worry about the terrible cascaded deletes that might occur later.

I have revisited after some trouble with running this inside local() from fabric. what seemed to be happening is that the pipe symbol mean that it was getting interpreted locally rather than on heroku. To sort this I wrapped in the command in quotes. Then had to used triple double quotes for the python strings inside the single quotes of the whole python command.

heroku run "echo 'from django.contrib.auth import get_user_model; User = get_user_model(); User.objects.filter(email="""admin@example.com""", is_superuser=True).delete(); User.objects.create_superuser("""admin""", """admin@example.com""", """nimda""")' | python manage.py shell"

python manage.py shell -c "from django.contrib.auth.models import User; \
                           User.objects.filter(username='admin1').exists() or \
                           User.objects.create_superuser('admin1',
                           'admin1@example.com', 'admin1')"

You can create a superuser in a custom command like this:

import os

from django.contrib.auth.models import User
from django.core.management import BaseCommand, call_command

from immo_project import settings


class Command(BaseCommand):
    def handle(self, *args, **options):
        call_command('createsuperuser', interactive=False, username='admin', email='test@example.com')
        user = User.objects.get(username='admin')
        user.set_password('password')
        user.save()

very easy, listen on post syncdb signal and read superuser credentials from a configuration file and apply it.

Check out django-finalware, and its predecessor django-bootup [deprecated]

This small python script could create a normal user or a superuser

#!/usr/bin/env python

import os
import sys
import argparse
import random
import string
import django


def main(arguments):

    parser = argparse.ArgumentParser()
    parser.add_argument('--username', dest='username', type=str)
    parser.add_argument('--email', dest='email', type=str)
    parser.add_argument('--settings', dest='settings', type=str)
    parser.add_argument('--project_dir', dest='project_dir', type=str)
    parser.add_argument('--password', dest='password', type=str, required=False)
    parser.add_argument('--superuser', dest='superuser', action='store_true', required=False)

    args = parser.parse_args()

    sys.path.append(args.project_dir)
    os.environ['DJANGO_SETTINGS_MODULE'] = args.settings
    from django.contrib.auth.models import User
    django.setup()

    username = args.username
    email = args.email
    password = ''.join(random.sample(string.letters, 20)) if args.password is None else args.password
    superuser = args.superuser 

    try:
        user_obj = User.objects.get(username=args.username)
        user_obj.set_password(password)
        user_obj.save()
    except User.DoesNotExist:
    if superuser:
            User.objects.create_superuser(username, email, password)
    else:
        User.objects.create_user(username, email, password)

    print password


if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))

–superuser & –password are not mandatory.

If –superuser is not defined, normal user will be created
If –password is not defined, a random password will be generated

    Ex : 
        /var/www/vhosts/PROJECT/python27/bin/python /usr/local/sbin/manage_dja_superusertest.py --username USERNAME --email TEST@domain.tld --project_dir /var/www/vhosts/PROJECT/PROJECT/ --settings PROJECT.settings.env 

This is what I cobbled together for Heroku post_deploy and a predefined app.json variable:

if [[ -n "$CREATE_SUPER_USER" ]]; then
    echo "==> Creating super user"
    cd /app/example_project/src
    printf "from django.contrib.auth.models import User\nif not User.objects.exists(): User.objects.create_superuser(*'$CREATE_SUPER_USER'.split(':'))" | python /app/example_project/manage.py shell
fi

With this you can have a single env variable:

CREATE_SUPER_USER=admin:admin@example.com:password

I like the shell –command option, but not sure how the get newline character in the command script. Without the newline the if expression results in syntax error.

python manage.py shell < mysite/create_superuser.py

mysite/create_superuser.py

from decouple import config
from django.db import IntegrityError

# getting name,email & password from env variables
DJANGO_SU_NAME = config('DJANGO_SU_NAME')
DJANGO_SU_EMAIL = config('DJANGO_SU_EMAIL')
DJANGO_SU_PASSWORD = config('DJANGO_SU_PASSWORD')

try:
    superuser = User.objects.create_superuser(
        username=DJANGO_SU_NAME,
        email=DJANGO_SU_EMAIL,
        password=DJANGO_SU_PASSWORD)
    superuser.save()
except IntegrityError:
    print(f"Super User with username {DJANGO_SU_NAME} is already present")
except Exception as e:
    print(e)

For those who just want to host a django website on AWS Elastic Beanstalk (even without docker) and are stuck on the superuser part, create a file called 01_migrate.sh in .platform > hooks > postdeploy and input the below:

#!/bin/bash

source /var/app/venv/*/bin/activate && { python migrate.py createsuperuser --noinput; }

You can then add DJANGO_SUPERUSER_PASSWORD, DJANGO_SUPERUSER_USERNAME, DJANGO_SUPERUSER_EMAIL to the configuration section of the application environment.

Then add the below to the folder .ebextentions > django.config

container_commands:
    01_chmod1:
         command: "chmod +x .platform/hooks/postdeploy/01_migrate.sh"

That will create your superuser in a secure way, with the same logic you can also run migrations and collectstatic by adding to the 01_migrate.sh file.

send command to docker-compose

almost same answer like above.

docker-compose exec service_name sh -c "
from django.contrib.auth.models import User


username = \"admin\"
email = \"admin@example.com\"
password = \"password\"
User.objects.create_superuser(username, email, password)
"

I do not mentioned about validate or check user before creation. if you care about that, check above answers.

In my case, we are automating with some bash, docker, helm, we were having some issues escaping some commas and quotes, after some try/error we figured out the easiest way (easiest for us), this single line command based on the doc shared previously did the trick

DJANGO_SUPERUSER_PASSWORD=12345 DJANGO_SUPERUSER_USERNAME=pacho DJANGO_SUPERUSER_EMAIL=pacho@gmail.com python manage.py createsuperuser --noinput

The best solution I have found also also personally used is following:

echo "from django.contrib.auth.models import User; User.objects.filter(username='username').exists() or User.objects.create_superuser('username', 'email@mail.com','passswordd' )" | python manage.py shell

All other specified solutions above gave me error that user already exists. I am using this as a shell script to run when even i deploy me new Django API on Kubernetes.

hope it helps someone.

Go to command prompt and type:

C:\WINDOWS\system32>pip install django-createsuperuser
Collecting django-createsuperuser
  Downloading https://files.pythonhosted.org/packages/93/8c/344c6367afa62b709adebee039d09229675f1ee34d424180fcee9ed857a5/django-createsuperuser-2019.4.13.tar.gz
Requirement already satisfied: Django>1.0 in c:\programdata\anaconda3\lib\site-packages (from django-createsuperuser) (2.2.1)
Requirement already satisfied: setuptools in c:\programdata\anaconda3\lib\site-packages (from django-createsuperuser) (41.0.1)
Requirement already satisfied: sqlparse in c:\programdata\anaconda3\lib\site-packages (from Django>1.0->django-createsuperuser) (0.3.0)
Requirement already satisfied: pytz in c:\programdata\anaconda3\lib\site-packages (from Django>1.0->django-createsuperuser) (2018.7)
Building wheels for collected packages: django-createsuperuser
  Running setup.py bdist_wheel for django-createsuperuser ... done
  Stored in directory: C:\Users\Arif Khan\AppData\Local\pip\Cache\wheels\0c\96\2a\e73e95bd420e844d3da1c9d3e496c92642a4f2181535440db2
Successfully built django-createsuperuser
Installing collected packages: django-createsuperuser

if not executed the migration then go to django application folder and execute following

1. python manage.py migrate
2. python manage.py createsuperuser

then bingo.