Skąd wiesz, czy memcached coś robi?

Testuję użycie memcached do buforowania widoków django. Jak mogę sprawdzić, czy memcached faktycznie buforuje cokolwiek z wiersza poleceń Linuksa?

Wiem, że to pytanie jest stare, ale oto inne przydatne podejście do testowania memcached z django:

Jak wspomniał @Jacob, możesz uruchomić memcached w trybie bardzo szczegółowym (nie jako demon):

memcached -vv

Aby przetestować konfigurację pamięci podręcznej django, możesz użyć interfejsu API pamięci podręcznej niskiego poziomu.

1. Najpierw uruchom interpreter Pythona i załaduj ustawienia projektu django:

   python manage.py shell
   

2. Z poziomu powłoki możesz użyć niskopoziomowego interfejsu API pamięci podręcznej, aby przetestować serwer memcache:

   from django.core.cache import cache
   cache.set('test', 'test value')
   

Jeśli konfiguracja pamięci podręcznej jest poprawna, w memcache powinny pojawić się wyniki podobne do tego:

<32 set :1:test 0 300 10
>32 STORED

Możesz użyć oficjalnego skryptu Perla:

memcached-tool 127.0.0.1:11211 stats 

Lub po prostu użyj telnetu i polecenia stats np:

# telnet localhost [memcacheport]
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
stats
STAT pid 2239
STAT uptime 10228704
STAT time 1236714928
STAT version 1.2.3
STAT pointer_size 32
STAT rusage_user 2781.185813
STAT rusage_system 2187.764726
STAT curr_items 598669
STAT total_items 31363235
STAT bytes 37540884
STAT curr_connections 131
STAT total_connections 8666
STAT connection_structures 267
STAT cmd_get 27
STAT cmd_set 30694598
STAT get_hits 16
STAT get_misses 11
STAT evictions 0
STAT bytes_read 2346004016
STAT bytes_written 388732988
STAT limit_maxbytes 268435456
STAT threads 4
END

Uruchom memcache nie jako demona, ale normalnie, więc po prostu uruchom memcached -vvbardzo rozwlekłe. Zobaczysz, kiedy pliki i zestawy pojawią się na serwerze memcache.

Prostym sposobem na sprawdzenie działania memcache było wkradnięcie zakomentowanego znacznika czasu na każdej wyświetlanej stronie. Jeśli sygnatura czasowa pozostała taka sama przy wielu żądaniach skierowanych do strony, oznacza to, że strona była buforowana przez memcache.

W ustawieniach Django skonfigurowałem również mechanizm pamięci podręcznej tak, aby korzystał z pamięci podręcznej plików w systemie plików (bardzo wolno), ale po wejściu na strony zobaczyłem, że w ścieżce pliku znajdują się rzeczywiste pliki pamięci podręcznej, więc mogłem potwierdzić, że buforowanie jest aktywny w Django.

Użyłem obu tych kroków, aby rozwiązać problem z buforowaniem. Właściwie nie miałem poprawnie włączonego buforowania w Django. Nowszą metodą aktywacji buforowania jest użycie oprogramowania pośredniego „django.middleware.cache.CacheMiddleware” (a nie oprogramowania pośredniego z dwoma elementami oprogramowania pośredniego, które muszą być pierwszymi / ostatnimi ustawieniami oprogramowania pośredniego).

Memcached może faktycznie samodzielnie zapisywać w pliku dziennika, bez konieczności ręcznego ponownego uruchamiania. /etc/init.d/memcachedSkrypt init ( /usr/lib/systemd/system/memcached.servicena EL7 +; ugh) mogą dzwonić memcached z opcjami określonymi w /etc/memcached.conf(lub /etc/sysconfig/memcachedna EL5 +). Wśród tych opcji jest szczegółowość i ścieżka pliku dziennika.

Krótko mówiąc, wystarczy dodać (lub odkomentować) te dwie linie do tego pliku conf / sysconfig ...

-vv
logfile /path/to/log

... i zrestartuj demona za pomocą service memcached restart(EL3-7) lub /etc/init.d/memcached restart(debuntus)

A potem możesz monitorować ten dziennik w tradycyjny sposób tail -f /path/to/log, na przykład.

W wierszu poleceń wypróbuj poniższe polecenie:

echo stats | nc 127.0.0.1 11211

Jeśli nic nie zwróci, memcache nie będzie działać. W przeciwnym razie powinien zwrócić kilka statystyk, w tym czas pracy (oraz liczbę trafień i chybień)

Artykuł referencyjny jest tutaj, https://www.percona.com/blog/2008/11/26/a-quick-way-to-get-memcached-status/

Aby zobaczyć zmiany co 2 sekundy:

watch "echo stats | nc 127.0.0.1 11211"

Aby rozszerzyć odpowiedź węzła, możesz użyć socat UNIX-CONNECT:/var/run/memcached.sock STDINdo debugowania gniazda unixowego.

Przykład:

$ socat UNIX-CONNECT:/var/run/memcached.sock STDIN
stats
STAT pid 931
STAT uptime 10
STAT time 1378574384
STAT version 1.4.13
STAT libevent 2.0.19-stable
STAT pointer_size 32
STAT rusage_user 0.000000
STAT rusage_system 0.015625
STAT curr_connections 1
STAT total_connections 2
STAT connection_structures 2

W Bash możesz sprawdzić statystyki memcache za pomocą tego polecenia:

exec 3<>/dev/tcp/localhost/11211; printf "stats\nquit\n" >&3; cat <&3

Aby opróżnić pamięć podręczną, użyj memflushpolecenia:

echo flush_all >/dev/tcp/localhost/11211

i sprawdź, czy statystyki wzrosły.

Aby zrzucić wszystkie obiekty w pamięci podręcznej, użyj polecenia memdumplub memcdump(część memcached/ libmemcachedpakiet):

memcdump --servers=localhost:11211

lub:

memdump --servers=localhost:11211

Jeśli używasz PHP, aby zobaczyć, czy jest obsługiwany, należy sprawdzić przez: php -i | grep memcached.

Rysunek kalkowy

Aby sprawdzić, jaki proces memcached dokładnie przetwarza, możesz użyć do tego snifferów lub debuggerów sieciowych (np. W stracesystemie Linux lub dtrace/ dtrussna Unix / OS X). Sprawdź kilka przykładów poniżej.

Strace

sudo strace -e read,write -fp $(pgrep memcached)

Aby lepiej sformatować wyjście, sprawdź: Jak przetworzyć strace w powłoce na zwykły tekst?

Dtruss

Dtruss to opakowanie dtrace, które jest dostępne w systemach Unix. Uruchom jako:

sudo dtruss -t read -fp $(pgrep memcached)

Tcpdump

sudo tcpdump -i lo0 -s1500 -w- -ln port 11211 | strings -10

Możesz przetestować memcached lub dowolny serwer za pomocą poniższego skryptu

lsof -i :11211 | grep 'LISTEN'>/dev/null 2>/dev/null;echo $?

jeśli zwraca 0 to serwer faktycznie działa lub jeśli 1 nie jest to tak jeśli chcesz wiedzieć że serwer faktycznie działa na jakimś porcie użyj następującego skryptu

lsof -i :11211 | grep 'LISTEN'>/dev/null 2>/dev/null;
if [ $? -eq 0]; then
    echo "Your memcache server is running"
else
    echo "No its not running"
fi

Czy możesz użyć curl, aby pobrać stronę kilkaset razy i zsynchronizować wyniki? Możesz również przyjrzeć się uruchomieniu procesu na serwerze, który symuluje duże obciążenie procesora / dysku.

Napisałem expectskrypt, is-memcached-runningktóry sprawdza, czy memcached działa na kombinacji host / port (działa jako is-memcached-running localhost 11211):

#! /usr/bin/env expect
set timeout 1
set ip [lindex $argv 0]
set port [lindex $argv 1]
spawn telnet $ip $port
expect "Escape character is '^]'."
send stats\r
expect "END"
send quit\r
expect eof

Jeśli uruchamiasz swój system z Makefilereguły, możesz uzależnić swój start od celu make, który potwierdzi, że działa i działa (lub pomaga uzyskać ten stan). Jest rozwlekły, gdy sprawdzenie nie ułatwia nam debugowania nieudanych uruchomień ci, instaluje memcached, gdy go brakuje, i jest zwięzły i na temat, w przeciwnym razie:

#! /bin/bash
if [[ "$(type -P memcached)" ]]; then
  echo 'memcached installed; checking if it is running'
  memcached_debug=`mktemp memcache-check.XXXXX`
  if is-memcached-running localhost 11211 >$memcached_debug 2>&1; then
    echo 'Yep; memcached online'
  else
    cat $memcached_debug
    echo
    echo '****** Error: memcached is not running! ******'
    if [[ "$OSTYPE" =~ ^darwin ]]; then
      echo
      echo 'Instructions to auto-spawn on login (or just start now) are shown'
      echo 'at the end of a "brew install memcached" run (try now, if you did'
      echo 'not do so already) or, if you did, after a "brew info memcached".'
      echo
    fi
    exit 1
  fi
  rm -f $memcached_debug
else
  echo memcached was not found on your system.

  if [[ "$OSTYPE" =~ ^darwin ]]; then
    brew install memcached
  elif [[ "$OSTYPE" =~ ^linux ]]; then
    sudo apt-get install memcached
  else
    exit 1
  fi
fi

Po poście Aryashree pomogło mi to uzyskać błąd, jeśli memcached nie działa lokalnie:

import subprocess

port = 11211
res = subprocess.Popen(f"echo stats | nc 127.0.0.1 {port}", 
        shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

if res.stdout:
    lines = res.stdout.read() 
    lineArr = lines.split('\r\n')
    pidlineArr = lineArr[0].split(' ')
    pid = pidlineArr[-1]
    print(f"[MemCached] pid {pid} Running on port {port}")

else:
    raise RuntimeError(f"No Memcached is present on port {port}")

Używam Mezzanine i jedyną odpowiedzią, która mi pomogła, była odpowiedź Jacobsa. Więc zatrzymaj demona i uruchommemcached -vv