Como automatizar o createuperuser no django?

Quero auto run manage.py createsuperuseron djangomas nas encostas que não há nenhuma maneira de definir uma senha padrão.

Como posso conseguir isso? Ele deve ser independente no banco de dados django.

Se você referenciar o usuário diretamente, seu código não funcionará em projetos nos quais a configuração AUTH_USER_MODEL foi alterada para um modelo de usuário diferente. Uma maneira mais genérica de criar o usuário seria:

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

RESPOSTA ORIGINAL

Aqui está uma versão simples do script para criar um superusuário:

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

Eu mesmo estava procurando uma resposta para isso. Eu decidi criar um comando Django que estende o createsuperusercomando base ( 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()

Exemplo de uso:

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

Isso tem a vantagem de ainda suportar o uso padrão do comando, além de permitir o uso não interativo para especificar uma senha.

Eu uso './manage.py shell -c':

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

Isso não usa um eco extra; isso tem o benefício de que você pode transmiti-lo para um contêiner de docker para execução. Sem a necessidade de usar sh -c "..." que o leva a citar escapando do inferno.

E lembre-se de que primeiro vem o nome de usuário, do que o email.

Se você possui um modelo de usuário personalizado, é necessário importá-lo e não auth.models.User

Eu sugeriria a execução de uma migração de dados ; portanto, quando as migrações são aplicadas ao projeto, um superusuário é criado como parte das migrações. O nome de usuário e a senha podem ser configurados como variáveis ​​de ambiente. Isso também é útil ao executar um aplicativo em um contêiner (veja este tópico como um exemplo)

Sua migração de dados ficaria assim:

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_DB_NAME = os.environ.get('DJANGO_DB_NAME', "default")
        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),
    ]

Espero que ajude!

EDIT : Alguns podem levantar a questão de como definir essas variáveis ​​de ambiente e tornar o Django ciente delas. Existem várias maneiras e isso foi respondido em outras postagens do SO, mas, como um ponteiro rápido, criar um .envarquivo é uma boa idéia. Você pode usar o pacote python-dotenv , mas se você configurou um ambiente virtual com o pipenv, ele definirá automaticamente os envvars no seu .envarquivo. Da mesma forma, a execução do aplicativo via docker-compose pode ser lida no seu .envarquivo.

A partir de Django 3.0, você pode usar o padrão createsuperuser --noinputde comando e defina todos os campos obrigatórios (incluindo senha) como variáveis de ambiente DJANGO_SUPERUSER_PASSWORD, DJANGO_SUPERUSER_USERNAME, DJANGO_SUPERUSER_EMAILpor exemplo. --noinputsinalizador é obrigatório.

Isso vem dos documentos originais: https://docs.djangoproject.com/en/3.0/ref/django-admin/#django-admin-createsuperuser

e acabei de verificar - funciona. Agora você pode exportar facilmente esses vars de ambiente e adicionar createsuperuserseus scripts e pipelines.

Você pode escrever um script python simples para lidar com a automação da criação de superusuário. O Usermodelo é apenas um modelo normal do Django, então você deve seguir o processo normal de escrever um script Django independente. 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()

Você também pode passar createsuperuseralgumas opções, a saber, --noinpute --username, que permitiriam criar automaticamente novos superusuários, mas eles não seriam capazes de efetuar login até você definir uma senha para eles.

Resposta mais votada atual:

• Exclui o usuário, se houver, e conforme observado por @Groady nos comentários, você corre o risco de excluir acidentalmente quaisquer registros associados por meio de uma exclusão em cascata.
• Verifica a existência do superusuário filtrando por e-mail, se dois superusuários tiverem o mesmo e-mail, ele saberá qual deles será excluído.
• É complicado atualizar os parâmetros do script: nome de usuário, senha e email.
• Não registra o que fez.

Uma versão melhorada seria:

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

DJANGO_SUPERUSER_USERNAME=testuser \
DJANGO_SUPERUSER_PASSWORD=testpass \
python manage.py createsuperuser --noinput

Documentação para o comando createuser

Eu usei o Tk421 em uma linha, mas recebi uma mensagem de erro como: 1) Acho que estou usando uma versão posterior do Django (1.10) Manager isn't available; 'auth.User' has been swapped for 'users.User'2) a ordem dos parâmetros para create_superuser estava errada.

Então substituí-o por:

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

e o que mais me agradou é que ele também funciona em uma implantação heroku:

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

Isso funcionará bem repetidamente. Estou usando-o no início de um projeto, portanto, não se preocupe com as terríveis exclusões em cascata que podem ocorrer mais tarde.

Eu revisitei após alguns problemas com a execução deste local dentro () do fabric. o que parecia estar acontecendo é que o símbolo do cachimbo significa que estava sendo interpretado localmente, e não no heroku. Para classificar isso, envolvi o comando entre aspas. Em seguida, teve que usar aspas duplas triplas para as seqüências de caracteres python dentro das aspas simples de todo o comando python.

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"

Uma solução baseada na abordagem de Adam Charnock acima já está disponível como um pacote Python. São necessários três passos:

1. Instalar: pip install django-createsuperuserwithpassword

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

3. Aplique:

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

É isso aí.

muito fácil, ouça o sinal post syncdb, leia as credenciais do superusuário de um arquivo de configuração e aplique-o.

check-out django-bootup

https://github.com/un33k/django-bootup/blob/master/README

Esse pequeno script python pode criar um usuário normal ou um superusuário

#!/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 e --password não são obrigatórios.

Se --superuser não estiver definido, o usuário normal será criado. Se --password não estiver definido, uma senha aleatória será gerada

    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 

Isto é o que eu juntei para Heroku post_deploy e uma variável app.json predefinida :

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

Com isso, você pode ter uma única variável env:

CREATE_SUPER_USER=admin:admin@example.com:password

Eu gosto da opção shell --command , mas não sei como o caractere get newline no script de comando. Sem a nova linha, a ifexpressão resulta em erro de sintaxe.

Vá para o prompt de comando e digite:

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

se não executou a migração, vá para a pasta do aplicativo django e execute as seguintes

1. python manage.py migrate
2. python manage.py cria superusuário

depois bingo.

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')"

Com shell_plus é muito mais fácil, na verdade

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

Como outros mencionados, no Django 3.0 você pode passar as credenciais através de variáveis ​​de ambiente. No entanto, essa abordagem é muito mais flexível, pois permite executar qualquer outra tarefa mais complicada, como remover todos os usuários de testes, etc.