Daemonizing Sellerie

Question

folgenden Anweisungen gefunden here, kopierte ich the script from github in /etc/init.d/celeryd, dann machte es ausführbar;

$ ll /etc/init.d/celeryd 
-rwxr-xr-x 1 root root 9481 Feb 19 11:27 /etc/init.d/celeryd* 

I erstellt Konfigurationsdatei /etc/default/celeryd gemäß den Anweisungen:

# Names of nodes to start 
# most will only start one node: 
#CELERYD_NODES="worker1" 
# but you can also start multiple and configure settings 
# for each in CELERYD_OPTS (see `celery multi --help` for examples). 
CELERYD_NODES="worker1 worker2 worker3" 

# Absolute or relative path to the 'celery' command: 
CELERY_BIN="/usr/local/bin/celery" 
#CELERY_BIN="/virtualenvs/def/bin/celery" 

# App instance to use 
# comment out this line if you don't use an app 
#CELERY_APP="proj" 
# or fully qualified: 
#CELERY_APP="proj.tasks:app" 

# Where to chdir at start. 
CELERYD_CHDIR="/path/to/folder/containing/tasks/" 

# Extra command-line arguments to the worker 
CELERYD_OPTS="--time-limit=3000 --concurrency=3 --config=celeryconfig" 

# %N will be replaced with the first part of 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. 
# You need to create this user manually (or you can choose 
# a user/group combination that already exists, e.g. nobody). 
CELERYD_USER="celery" 
CELERYD_GROUP="celery" 

# If enabled pid and log directories will be created if missing, 
# and owned by the userid/group configured. 
CELERY_CREATE_DIRS=1 

Hinweis: Ich habe die --config = celeryconfig Teil in CELERYD_OPTS hinzugefügt.

habe ich einen neuen Benutzer Sellerie mit

sudo useradd -N -M --system -s /bin/false celery 

und dann Gruppe Sellerie und hinzugefügt Benutzer sie erstellt:

$ id celery 
uid=999(celery) gid=1005(celery) groups=1005(celery) 

I verwendet chown Sellerie: für Ordner Sellerie:

/var/run/Sellerie/

/var/log/Sellerie/

Wenn ich versuche, den Dienst zu starten, erhalte ich keinen Hinweis auf Fehler:

$ sudo service celeryd start 
celery init v10.0. 
Using config script: /etc/default/celeryd 

aber Status gibt mir "keine pids wurden gefunden":

$ sudo service celeryd status 
celery init v10.0. 
Using config script: /etc/default/celeryd 
celeryd is stopped: no pids were found 

und in der Tat gibt ps -ef keine Ergebnisse und keine PID-Datei oder Protokolldateien erstellt:

$ ll /var/run/celery 
total 0 
drwxr-sr-x 2 celery celery 40 Feb 19 14:13 ./ 
drwxr-xr-x 16 root root 620 Feb 19 12:35 ../ 

$ ll /var/log/celery 
total 8 
drwxr-sr-x 2 celery celery 4096 Feb 19 14:13 ./ 
drwxr-xr-x 13 root root 4096 Feb 19 11:37 ../ 

Zusätzliche Informationen:

$ pip freeze | grep celery 
celery==3.1.9 

Was bin ich? Wo sollte ich nach weiteren Hinweisen suchen, warum der Sellerie nicht beginnt?

Answer 1

Ich repliziert Ihre Schritte und es ergab sich das gleiche Problem. Das Problem war, dass der Sellerie-Benutzer keine Schale hatte.

sudo useradd -N -M --system -s /bin/false celery 

Ändern -s /bin/false zu -s /bin/bash das Problem behoben. Der Grund dafür ist, dass das Skript celeryd init die Shell des Sellerie-Benutzers verwendet, um Sellerie-Befehle auszuführen. Ohne eine Shell wird der su Befehl unten still ausgeführt.

_chuid() { 
    su "$CELERYD_USER" -c "$CELERYD_MULTI $*" 
} 

Answer 2

habe ich eine etwas andere Version des Init-Skript, hier zur Verfügung gestellt:

#!/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.celeryproject.org/en/latest/tutorials/daemonizing.html#generic-init-scripts 


### 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 
# 
# 
# To implement separate init scripts, do NOT copy this script. Instead, 
# symlink it. I.e., if my new application, "little-worker" needs an init, I 
# should just use: 
# 
# ln -s /etc/init.d/celeryd /etc/init.d/little-worker 
# 
# You can then configure this by manipulating /etc/default/little-worker. 
# 
# If you want to have separate LSB headers in each script you can source this 
# script instead of symlinking: 
# # ... 
# ### END INIT INFO 
# source /etc/init.d/celeryd 
# 
# Setting `SCRIPT_NAME` here allows you to symlink/source this init script, 
# making it easy to run multiple processes on the system. 
SCRIPT_NAME="$(basename $0)" 

DEFAULT_PID_FILE="/var/run/celery/${SCRIPT_NAME}/%n.pid" 
DEFAULT_LOG_FILE="/var/log/celery/${SCRIPT_NAME}/%n.log" 
DEFAULT_LOG_LEVEL="INFO" 
DEFAULT_NODES="celery" 
DEFAULT_CELERYD="-m celery worker --detach" 

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

test -f "$CELERY_DEFAULTS" && . "$CELERY_DEFAULTS" 

# Sets --app argument for CELERY_BIN 
CELERY_APP_ARG="" 
if [ ! -z "$CELERY_APP" ]; then 
    CELERY_APP_ARG="--app=$CELERY_APP" 
fi 


# Set CELERY_CREATE_DIRS to always create log/pid dirs. 
CELERY_CREATE_DIRS=${CELERY_CREATE_DIRS:-0} 
CELERY_CREATE_RUNDIR=$CELERY_CREATE_DIRS 
CELERY_CREATE_LOGDIR=$CELERY_CREATE_DIRS 
if [ -z "$CELERYD_PID_FILE" ]; then 
    CELERYD_PID_FILE="$DEFAULT_PID_FILE" 
    CELERY_CREATE_RUNDIR=1 
fi 
if [ -z "$CELERYD_LOG_FILE" ]; then 
    CELERYD_LOG_FILE="$DEFAULT_LOG_FILE" 
    CELERY_CREATE_LOGDIR=1 
fi 

CELERYD_LOG_LEVEL=${CELERYD_LOG_LEVEL:-${CELERYD_LOGLEVEL:-$DEFAULT_LOG_LEVEL}} 
CELERY_BIN=${CELERY_BIN:-"celery"} 
CELERYD_MULTI=${CELERYD_MULTI:-"$CELERY_BIN multi"} 
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` 

# Extra start-stop-daemon options, like user/group. 
if [ -n "$CELERYD_USER" ]; then 
    DAEMON_OPTS="$DAEMON_OPTS --uid=$CELERYD_USER" 
fi 
if [ -n "$CELERYD_GROUP" ]; then 
    DAEMON_OPTS="$DAEMON_OPTS --gid=$CELERYD_GROUP" 
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 75 # EX_TEMPFAIL 
    fi 
} 


maybe_die() { 
    if [ $? -ne 0 ]; then 
     echo "Exiting: $* (errno $?)" 
     exit 77 # EX_NOPERM 
    fi 
} 

create_default_dir() { 
    if [ ! -d "$1" ]; then 
     echo "- Creating default directory: '$1'" 
     mkdir -p "$1" 
     maybe_die "Couldn't create directory $1" 
     echo "- Changing permissions of '$1' to 02755" 
     chmod 02755 "$1" 
     maybe_die "Couldn't change permissions for $1" 
     if [ -n "$CELERYD_USER" ]; then 
      echo "- Changing owner of '$1' to '$CELERYD_USER'" 
      chown "$CELERYD_USER" "$1" 
      maybe_die "Couldn't change owner of $1" 
     fi 
     if [ -n "$CELERYD_GROUP" ]; then 
      echo "- Changing group of '$1' to '$CELERYD_GROUP'" 
      chgrp "$CELERYD_GROUP" "$1" 
      maybe_die "Couldn't change group of $1" 
     fi 
    fi 
} 


check_paths() { 
    if [ $CELERY_CREATE_LOGDIR -eq 1 ]; then 
     create_default_dir "$CELERYD_LOG_DIR" 
    fi 
    if [ $CELERY_CREATE_RUNDIR -eq 1 ]; then 
     create_default_dir "$CELERYD_PID_DIR" 
    fi 
} 

create_paths() { 
    create_default_dir "$CELERYD_LOG_DIR" 
    create_default_dir "$CELERYD_PID_DIR" 
} 

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


_get_pid_files() { 
    [ ! -d "$CELERYD_PID_DIR" ] && return 
    echo `ls -1 "$CELERYD_PID_DIR"/*.pid 2> /dev/null` 
} 

_get_pids() { 
    local pid_files= 
    pid_files=`_get_pid_files` 
    [ -z "$pid_files" ] && echo "${SCRIPT_NAME} is stopped" && exit 1 

    for pid_file in $pid_files; do 
     local pid=`cat "$pid_file"` 
     local cleaned_pid=`echo "$pid" | sed -e 's/[^0-9]//g'` 
     if [ -z "$pid" ] || [ "$cleaned_pid" != "$pid" ]; then 
      echo "bad pid file ($pid_file)" 
      one_failed=true 
     else 
      echo "$pid" 
     fi 
    done 
} 

_get_worker_pids() { 
    local pids= 
    pids=`_get_pids` 
    local worker_pids= 
    for pid in $pids; do 
     worker_pids=`ps h --ppid $pid -o pid` 
     [ "$worker_pids" ] && echo "$worker_pids" || one_failed=true 
    done 
} 


start_workers() { 
    if [ -z "$CELERYD_ULIMIT" ]; then 
     ulimit $CELERYD_ULIMIT 
    fi 
    $CELERYD_MULTI $* start $CELERYD_NODES $DAEMON_OPTS  \ 
         --pidfile="$CELERYD_PID_FILE"  \ 
         --logfile="$CELERYD_LOG_FILE"  \ 
         --loglevel="$CELERYD_LOG_LEVEL" \ 
         $CELERY_APP_ARG     \ 
         $CELERYD_OPTS 
} 


dryrun() { 
    (C_FAKEFORK=1 start_workers --verbose) 
} 


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


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


kill_workers() { 
    $CELERYD_MULTI kill $CELERYD_NODES --pidfile="$CELERYD_PID_FILE" 
} 


restart_workers_graceful() { 
    local worker_pids= 
    worker_pids=`_get_worker_pids` 
    [ "$one_failed" ] && exit 1 

    for worker_pid in $worker_pids; do 
     local failed= 
     kill -HUP $worker_pid 2> /dev/null || failed=true 
     if [ "$failed" ]; then 
      echo "${SCRIPT_NAME} worker (pid $worker_pid) could not be restarted" 
      one_failed=true 
     else 
      echo "${SCRIPT_NAME} worker (pid $worker_pid) received SIGHUP" 
     fi 
    done 

    [ "$one_failed" ] && exit 1 || exit 0 
} 


check_status() { 
    local pid_files= 
    pid_files=`_get_pid_files` 
    [ -z "$pid_files" ] && echo "${SCRIPT_NAME} not running (no pidfile)" && exit 1 

    local one_failed= 
    for pid_file in $pid_files; do 
     local node=`basename "$pid_file" .pid` 
     local pid=`cat "$pid_file"` 
     local cleaned_pid=`echo "$pid" | sed -e 's/[^0-9]//g'` 
     if [ -z "$pid" ] || [ "$cleaned_pid" != "$pid" ]; then 
      echo "bad pid file ($pid_file)" 
     else 
      local failed= 
      kill -0 $pid 2> /dev/null || failed=true 
      if [ "$failed" ]; then 
       echo "${SCRIPT_NAME} (node $node) (pid $pid) is stopped, but pid file exists!" 
       one_failed=true 
      else 
       echo "${SCRIPT_NAME} (node $node) (pid $pid) is running..." 
      fi 
     fi 
    done 

    [ "$one_failed" ] && exit 1 || exit 0 
} 


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

    stop) 
     check_dev_null 
     check_paths 
     stop_workers 
    ;; 

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

    status) 
     check_status 
    ;; 

    restart) 
     check_dev_null 
     check_paths 
     restart_workers 
    ;; 

    graceful) 
     check_dev_null 
     restart_workers_graceful 
    ;; 

    kill) 
     check_dev_null 
     kill_workers 
    ;; 

    dryrun) 
     check_dev_null 
     dryrun 
    ;; 

    try-restart) 
     check_dev_null 
     check_paths 
     restart_workers 
    ;; 

    create-paths) 
     check_dev_null 
     create_paths 
    ;; 

    check-paths) 
     check_dev_null 
     check_paths 
    ;; 

    *) 
     echo "Usage: /etc/init.d/${SCRIPT_NAME} {start|stop|restart|graceful|kill|dryrun|create-paths}" 
     exit 64 # EX_USAGE 
    ;; 
esac 

exit 0 

es mit der dryrun Option gab mir den genauen Befehl die init Lauf wurde zu konstruieren.

ausgeführt wird, den Befehl nach den zwei folgenden Optionen zu entfernen:

--detach 
--logfile 

mir erlaubt, es in der Konsole laufen zu lassen und den Python-Fehlertrace beobachten.

Es endete als ich das redis Modul neu installieren musste (die ich als Backend verwenden) von pip

werde ich die zwei Init-Skripte diff mit einer Mischung aus ihnen enden.

Answer 3

Ich habe das gleiche Problem erlebt. Selbst wenn ich versucht hätte, mit root user zu laufen, konnte ich keinen Worker starten. Dann stieß ich auf diese Antwort https://groups.google.com/forum/#!topic/celery-users/s8OFSdWdHo8 Es sagt im Grunde, dass der Benutzer, der Arbeiter ausführen wird, ein Home-Verzeichnis haben sollte.

Nachdem ich einen anderen Benutzer mit einem Home-Verzeichnis erstellt hatte, konnte ich die Worker starten.