W moim projekcie Django muszę wielokrotnie robić przetwarzanie w tle. To przetwarzanie wymaga dostępu do rzeczy Django, więc umieściłem go do poleceń Django i uruchomić go jako Cronjob. W tej chwili zdaję sobie sprawę, że muszę częściej robić niektóre z nich (Cronjob ma ograniczenie polecenia wywołania najwyżej co 1 minutę). Innym problemem jest to, że nie mam wystarczającej kontroli, aby chronić prowadzenie tego samego polecenia w jednym czasie. Dzieje się tak, gdy jedno przetwarzanie trwa dłużej niż minutę. Myślę, że powinienem je prowadzić jak demony, ale szukam czystego sposobu, aby zrobić to z Django. Czy kiedykolwiek napotkałeś ten problem lub znasz dla niego jakieś czyste rozwiązanie?

16
Piotr Niedzwiedz 16 listopad 2011, 22:05

4 odpowiedzi

Najlepsza odpowiedź

Robimy dużo przetwarzania w tle dla Django za pomocą selera http://ceryproject.org/. Wymaga to pewnego wysiłku, aby skonfigurować i jest trochę krzywej uczenia się, ale kiedy się skończy, to po prostu niesamowite.

15
Dmitry B. 16 listopad 2011, 18:12

Wzięliśmy więcej prostych podejść - napisz skrypt jako normalny skrypt z niekończącą się pętlą, która jest itera przez zapytanie, a następnie użyj supervise, aby zarządzać go jako demon. Zasadniczo jest to potrzebne do uruchomienia demona: -

$ sudo apt-get install daemontools daemontools-run
$ mkdir /etc/service/sendmsevad
$ echo -> /etc/service/sendmsevad/run
#!/bin/bash
exec /usr/local/bin/sendmsgd
$ sudo svc -d  /etc/service/sendmsgd
$ sudo svc -u  /etc/service/sendmsgd
$ sudo svstat /etc/service/sendmsgd
/etc/service/sendmsg: up (pid 10521) 479 seconds

Więcej o tym - Jak mogę daonize arbitralne Skrypt w UNIX?

Teraz /usr/local/bin/sendmsgd może wyglądać jak: -

def main(args=None):
    while True:
        process_messages()
        time.sleep(10)

if __name__ == '__main__':
    import signal
    def signal_handler(signal, frame):
        sys.exit(0)
    signal.signal(signal.SIGINT, signal_handler)

    main(sys.argv)
3
Community 23 maj 2017, 10:27

Mam problemy ze zrozumieniem dokumentacji na stronie Selera. Znalazłem Ta strona. Co zrobił dobrą robotę wyjaśniającą rzeczy. Mam rzeczy pracujące na systemie centos 6.2 z Django-1.5 + Seler-3.0.17 + SQLite3. Jedynym problemem, jakie miałem, był błąd znalezienie modułu Ustawienia, które muszę zmienić na "myprojectName.settings".

Krok 1. Wprowadź następujący skrypt w / etc / Default / Celeryd. Zauważ, że będziesz musiał zmienić część zawartości w zależności od systemu.

# Name of nodes to start, here we have a single node
CELERYD_NODES="w1"

# Where to chdir at start.
CELERYD_CHDIR="/var/www/some_folder/Myproject/"

# Python interpreter from environment, if using virtualenv
ENV_PYTHON="/somewhere/.virtualenvs/MyProject/bin/python"

# How to call "manage.py celeryd_multi"
CELERYD_MULTI="$ENV_PYTHON $CELERYD_CHDIR/manage.py celeryd_multi"

# How to call "manage.py celeryctl"
CELERYCTL="$ENV_PYTHON $CELERYD_CHDIR/manage.py celeryctl"

# Extra arguments to celeryd
CELERYD_OPTS="--time-limit=300 --concurrency=8"

# Name of the celery config module, don't change this.
CELERY_CONFIG_MODULE="celeryconfig"

# %n will be replaced with the nodename.
CELERYD_LOG_FILE="/var/log/celery/%n.log"
CELERYD_PID_FILE="/var/run/celery/%n.pid"

# Workers should run as an unprivileged user.
CELERYD_USER="celery"
CELERYD_GROUP="celery"

# Set any other env vars here too!
PROJET_ENV="PRODUCTION"

# Name of the projects settings module.
# in this case is just settings and not the full path because it will change the dir to
# the project folder first.
export DJANGO_SETTINGS_MODULE="settings"

Krok 2. Ustaw skrypt poniżej w / etc / Default / Celeryd i zmień swoje uprawnienia

chmod +x /etc/init.d/celeryd 

Ten nie musi być modyfikowany. Źródło

#!/bin/sh -e
# ============================================
#  celeryd - Starts the Celery worker daemon.
# ============================================
#
# :Usage: /etc/init.d/celeryd {start|stop|force-reload|restart|try-restart|status}
# :Configuration file: /etc/default/celeryd
#
# See http://docs.celeryq.org/en/latest/cookbook/daemonizing.html#init-script-celeryd


### BEGIN INIT INFO
# Provides:          celeryd
# Required-Start:    $network $local_fs $remote_fs
# Required-Stop:     $network $local_fs $remote_fs
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: celery task worker daemon
### END INIT INFO

#set -e

DEFAULT_PID_FILE="/var/run/celeryd@%n.pid"
DEFAULT_LOG_FILE="/var/log/celeryd@%n.log"
DEFAULT_LOG_LEVEL="INFO"
DEFAULT_NODES="celery"
DEFAULT_CELERYD="-m celery.bin.celeryd_detach"

# /etc/init.d/celeryd: start and stop the celery task worker daemon.

CELERY_DEFAULTS=${CELERY_DEFAULTS:-"/etc/default/celeryd"}

test -f "$CELERY_DEFAULTS" && . "$CELERY_DEFAULTS"
if [ -f "/etc/default/celeryd" ]; then
    . /etc/default/celeryd
fi

CELERYD_PID_FILE=${CELERYD_PID_FILE:-${CELERYD_PIDFILE:-$DEFAULT_PID_FILE}}
CELERYD_LOG_FILE=${CELERYD_LOG_FILE:-${CELERYD_LOGFILE:-$DEFAULT_LOG_FILE}}
CELERYD_LOG_LEVEL=${CELERYD_LOG_LEVEL:-${CELERYD_LOGLEVEL:-$DEFAULT_LOG_LEVEL}}
CELERYD_MULTI=${CELERYD_MULTI:-"celeryd-multi"}
CELERYD=${CELERYD:-$DEFAULT_CELERYD}
CELERYCTL=${CELERYCTL:="celeryctl"}
CELERYD_NODES=${CELERYD_NODES:-$DEFAULT_NODES}

export CELERY_LOADER

if [ -n "$2" ]; then
    CELERYD_OPTS="$CELERYD_OPTS $2"
fi

CELERYD_LOG_DIR=`dirname $CELERYD_LOG_FILE`
CELERYD_PID_DIR=`dirname $CELERYD_PID_FILE`
if [ ! -d "$CELERYD_LOG_DIR" ]; then
    mkdir -p $CELERYD_LOG_DIR
fi
if [ ! -d "$CELERYD_PID_DIR" ]; then
    mkdir -p $CELERYD_PID_DIR
fi

# Extra start-stop-daemon options, like user/group.
if [ -n "$CELERYD_USER" ]; then
    DAEMON_OPTS="$DAEMON_OPTS --uid=$CELERYD_USER"
    chown "$CELERYD_USER" $CELERYD_LOG_DIR $CELERYD_PID_DIR
fi
if [ -n "$CELERYD_GROUP" ]; then
    DAEMON_OPTS="$DAEMON_OPTS --gid=$CELERYD_GROUP"
    chgrp "$CELERYD_GROUP" $CELERYD_LOG_DIR $CELERYD_PID_DIR
fi

if [ -n "$CELERYD_CHDIR" ]; then
    DAEMON_OPTS="$DAEMON_OPTS --workdir=\"$CELERYD_CHDIR\""
fi


check_dev_null() {
    if [ ! -c /dev/null ]; then
        echo "/dev/null is not a character device!"
        exit 1
    fi
}


export PATH="${PATH:+$PATH:}/usr/sbin:/sbin"


stop_workers () {
    $CELERYD_MULTI stop $CELERYD_NODES --pidfile="$CELERYD_PID_FILE"
}


start_workers () {
    $CELERYD_MULTI start $CELERYD_NODES $DAEMON_OPTS        \
                         --pidfile="$CELERYD_PID_FILE"      \
                         --logfile="$CELERYD_LOG_FILE"      \
                         --loglevel="$CELERYD_LOG_LEVEL"    \
                         --cmd="$CELERYD"                   \
                         $CELERYD_OPTS
}


restart_workers () {
    $CELERYD_MULTI restart $CELERYD_NODES $DAEMON_OPTS      \
                           --pidfile="$CELERYD_PID_FILE"    \
                           --logfile="$CELERYD_LOG_FILE"    \
                           --loglevel="$CELERYD_LOG_LEVEL"  \
                           --cmd="$CELERYD"                 \
                           $CELERYD_OPTS
}



case "$1" in
    start)
        check_dev_null
        start_workers
    ;;

    stop)
        check_dev_null
        stop_workers
    ;;

    reload|force-reload)
        echo "Use restart"
    ;;

    status)
        $CELERYCTL status $CELERYCTL_OPTS
    ;;

    restart)
        check_dev_null
        restart_workers
    ;;

    try-restart)
        check_dev_null
        restart_workers
    ;;

    *)
        echo "Usage: /etc/init.d/celeryd {start|stop|restart|try-restart|kill}"
        exit 1
    ;;
esac

exit 0

Krok 3. Użyj tych polecenia, aby rozpocząć, zatrzymać itp. Skrypt.

# to start celeryd
/etc/init.d/celeryd start

# to stop
/etc/init.d/celeryd stop

# see the status
/etc/init.d/celeryd status

# print the log in the screen
cat /var/log/celery/w1.log  

Jeśli masz problemy, była kilka komentarzy i innych zaleceń na stronie. Mam nadzieję, że pozostanie przez długi czas.

2
tweirick 27 maj 2013, 09:17

Możesz spróbować użyć regulatora tłuszczu, który może wziąć dowolny skrypt i dajonise. Może również wielokrotnie działać skrypty z odstępami określonymi w sekundach, a nawet wcale bez przedziału, więc zapobiegnie w każdym czasie, gdyby kiedykolwiek były dwa przypadki działające na raz.

Jest napisany w całości w C, więc jest bardzo stabilny, zaprojektowany do pracy przez miesiące lub lata - bez względu na to, ile twoje własne skrypty mogą się awarie. Bardzo łatwo jest wstać i uruchomić.

Może również zrobić wiele innych rzeczy, takich jak równoległy bieg sygnału, nawet dostosowywanie liczby instancji równoległych zgodnie z ilością pracy - ale myślę, że jest poza zakresem twoim wymogiem.

Na stronie internetowej istnieje wiele przypadków użytkowania i szczegółowych instrukcji. Jeśli potrzebujesz dodatkowej pomocy, po prostu skontaktuj się z nami, a następnie skontaktuj się z biletem wsparcia, a wrócę do ciebie tak szybko, jak tylko będę mógł.

Witryna jest: http://fat-controller.sourceforge.net/

0
SlappyTheFish 16 listopad 2011, 20:48