¿Cómo automatizar createuperuser en django?

Quiero ejecución automática manage.py createsuperuseren djangopero las costuras que no hay forma de establecer una contraseña por defecto.

¿Cómo puedo conseguir esto? Tiene que ser independiente de la base de datos de django.

Si hace referencia a User directamente, su código no funcionará en proyectos donde la configuración AUTH_USER_MODEL se haya cambiado a un modelo de usuario diferente. Una forma más genérica de crear el usuario sería:

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

RESPUESTA ORIGINAL

Aquí hay una versión simple del script para crear un superusuario:

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

Yo mismo buscaba una respuesta a esto. Decidí crear un comando de Django que amplíe el 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()

Ejemplo de uso:

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

Esto tiene la ventaja de que aún admite el uso de comandos predeterminado, al tiempo que permite un uso no interactivo para especificar una contraseña.

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

Esto no usa un eco adicional, esto tiene la ventaja de que puede pasarlo a un contenedor docker para su ejecución. Sin la necesidad de usar sh -c "..." lo que te lleva a comillas escapar del infierno.

Y recuerde que primero viene el nombre de usuario, que el correo electrónico.

Si tiene un modelo de usuario personalizado, debe importarlo y no auth.models.User

Sugeriría ejecutar una migración de datos , por lo que cuando se aplican migraciones al proyecto, se crea un superusuario como parte de las migraciones. El nombre de usuario y la contraseña se pueden configurar como variables de entorno. Esto también es útil cuando se ejecuta una aplicación en un contenedor (consulte este hilo como ejemplo)

Su migración de datos se vería así:

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 ayude!

EDITAR : Algunos podrían plantear la pregunta de cómo configurar estas variables de entorno y hacer que Django las conozca. Hay muchas formas y se ha respondido en otras publicaciones de SO, pero solo como un indicador rápido, crear un .envarchivo es una buena idea. Luego puede usar el paquete python-dotenv , pero si ha configurado un entorno virtual con pipenv, automáticamente establecerá los envvars en su .envarchivo. Del mismo modo, ejecutar su aplicación a través de docker-compose puede leer en su .envarchivo.

A partir de Django 3.0 se puede utilizar por defecto createsuperuser --noinputdel sistema y establezca todos los campos requeridos (incluyendo la contraseña) como variables de entorno DJANGO_SUPERUSER_PASSWORD, DJANGO_SUPERUSER_USERNAME, DJANGO_SUPERUSER_EMAILpor ejemplo. --noinputSe requiere bandera.

Esto proviene de los documentos originales: https://docs.djangoproject.com/en/3.0/ref/django-admin/#django-admin-createsuperuser

y acabo de comprobarlo, funciona. Ahora puede exportar fácilmente esas variables de entorno y agregarlas createsuperusera sus scripts y canalizaciones.

Podría escribir una secuencia de comandos de Python simple para manejar la automatización de la creación de superusuarios. El Usermodelo es solo un modelo Django normal, por lo que seguiría el proceso normal de escribir un script Django independiente. 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()

También puede pasar createsuperuseralgunas opciones, a saber, --noinputy --username, que le permitirían crear automáticamente nuevos superusuarios, pero no podrán iniciar sesión hasta que establezca una contraseña para ellos.

Respuesta actual más votada:

• Elimina al usuario si existe y, como señaló @Groady en los comentarios, corre el riesgo de eliminar involuntariamente cualquier registro asociado a través de una eliminación en cascada.
• Verifica la existencia de superusuarios filtrando por correo, por lo que si dos superusuarios tienen el mismo correo, Dios sabe cuál borrará.
• Es complicado actualizar los parámetros del script: nombre de usuario, contraseña y correo.
• No registra lo que hizo.

Una versión mejorada sería:

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

Documentación para el comando createuser

Usé Tk421 una línea pero recibí un mensaje de error como: 1) Creo que estoy usando una versión posterior de Django (1.10) Manager isn't available; 'auth.User' has been swapped for 'users.User'2) el orden de los parámetros para create_superuser era incorrecto.

Así que lo reemplacé con:

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

y lo que realmente me complació es que también funciona en una implementación de 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

Esto funcionará bien repetidamente. Lo estoy usando al comienzo de un proyecto, así que no se preocupe por las terribles eliminaciones en cascada que podrían ocurrir más adelante.

He vuelto a visitar después de algunos problemas al ejecutar esto dentro de local () desde fabric. lo que parecía estar sucediendo es que el símbolo de la tubería significaba que se estaba interpretando localmente en lugar de heroku. Para ordenar esto, envolví el comando entre comillas. Luego tuvo que usar comillas dobles triples para las cadenas de Python dentro de las comillas simples de todo el comando de 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"

Una solución basada en el enfoque de Adam Charnock anterior ya está disponible como paquete de Python. Toma tres pasos:

1. Instalar en pc: pip install django-createsuperuserwithpassword

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

3. Aplicar:

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

Eso es.

muy fácil, escuche la señal post syncdb y lea las credenciales de superusuario de un archivo de configuración y aplíquelo.

checkout django-bootup

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

Este pequeño script de Python podría crear un usuario normal o un superusuario

#!/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 no son obligatorios.

Si no se define --superuser, se creará un usuario normal.Si no se define --password, se generará una contraseña aleatoria

    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 

Esto es lo que improvisé para Heroku post_deploy y una variable 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

Con esto puedes tener una sola variable env:

CREATE_SUPER_USER=admin:admin@example.com:password

Me gusta la opción shell --command , pero no estoy seguro de cómo se obtiene el carácter de nueva línea en el script de comando. Sin el salto de línea, la ifexpresión da como resultado un error de sintaxis.

Vaya al símbolo del sistema y escriba:

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

si no se ejecutó la migración, vaya a la carpeta de la aplicación django y ejecute lo siguiente

1. python manage.py migrar
2. python manage.py crea superusuario

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

Con shell_plus es mucho más fácil en realidad

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

Como otros mencionaron, con Django 3.0 puede pasar las credenciales a través de variables de entorno. Sin embargo, este enfoque es mucho más flexible ya que le permite realizar cualquier otra tarea más complicada como eliminar todos los usuarios de pruebas, etc.