Reading time: 5 – 8 minutes
Cal dir que no sóc massa ordenat al presentar noves tecnologies ja que primer de tot vaig fer un bechmark sobre Gearman abans de fer-ne una introducció, doncs bé com que en aquest article vull parlar sobre unes possibles extensions sobre les que vull treballar amb Gearman primer de tot faré una petit introducció al projecte.
Introducció
Gearman és el que comunment anomenem un servidor de tasques, o sigui, que quan el nostre codi ha de demanar una tasca, funcionalitat, treball, o quelcom similar és molt interessant de cara a:
- l’escalavilitat: podem tenir tants servidors i/o processos consumint tasques com ens interessi.
- paral·lelisme: les tasques es poden consumir paral·lelament.
- balanceix de càrrega: podem fer map/reduce sobre les tasques i enviar-les als servidors que ens interessis per distribuir la càrrega.
- independència entre lleguatges: el codi que demana la tasca i el que consumeix la tasca poden ser totalment diferents, les llibreries que té Gearman són: PHP, Pearl, Ruby, C, Python, etc.
- interficie HTTP: a més disposa d’una interficie client HTTP que ens permetra injectar tasques desde llenguatges no suportats des de les llibreries de Gearman.
usar un servidor d’aquest tipus, ja que a més de permetrens demanar tasques síncrones, també podem demanar-li tasques asíncrones. O sigui, que no només no sabem qui ens esta fent la feina limitant-nos a rebre’n el resultat sinó que també podem demanar que aquesta feina es faci quan es pugui.
Per si tot això no fos poc encara hi ha més avantatges:
- Open Source
- Programat en C
- Petit i molt ràpid
- Suporta diversos backends: RAM, SQLite, Memcached, Tokyo Cabinet, etc.
La gent que va començar a implementar Gearman, van ser els de Danga Interactive famosos per LiveJournal i SixApart.
Les meves idees
Després d’aquesta introducció, ara ja puc parlar de les coses que voldria que fes Gearman però que no fa. Primer de tot he de parlar de les avantatges que tindria si pogués tenir un backend contra Redis. El que persegueixo al connectar Redis amb Gearman és aconseguir:
- persistència de tasques malgrat es reiniciï Gearman
- persistència de tasques en disc malgrat es reinciï Redis, gràcies a:
- l’escriptura asíncrona a disc
- bgrewriteaof: evita que per l’escriptura asíncrona d’informació es perdin dades al reinciar bruscament Redis
- publicar a un canal PubSub de Redis els canvis que es fan sobre una tasca que s’ha enviat a ‘background’
Integració amb Redis
Es tracata de fer el mateix que s’ha per integrar backend de tokyo cabinet: queue_libtokyocabinet.c el problema d’usar tokyo cabinet contra disc és la pèrdua brutal de rendiment respecte a usar-lo contra RAM, ja que les escriptures es fan de forma síncrona.
A nivell de codi les semblances més grans són amb: queue_libmemcached.c, malgrat el problema que té aquesta implementació és que cada cop que reiniciem memcached no tenim persistència de la informació que s’havia guardat en memcached, és com si les claus que s’han intrudit en l’anterior sessió s’haguessin esborrat. A més memcached no suporta persistència en les seves dades tampoc.
Així doncs, el que cal fer és agafar el millor d’amdues integracions i fer el mòdul amb Redis.
Subscripció a les actualitzacions d’una tasca via Redis
Quan s’envia una tasca en segon pla a Gearman aquest ens retorna un ‘Handler’ per poder preguntar sobre l’estat de la tasca, el problema és que si volem saber com evoluciona la tasca o que ens informi quan ha acabat no hi ha manera de saber-ho si no és fent ‘pooling’. Per altre banda, el ‘worker’ va actualitzant la tasca cada quan creu convenien perquè Gearman pugui saber quin és l’estat de la mateixa.
La meva idea és que al usar el backend de Redis, al mateix moment que s’actualitzi l’estat de la tasca també es publiqui (publish) a un canal PubSub de Redis de forma que el codi que ha enviat la tasca pugui subscriures (subscribe) a aquest canal i en temps real i amb un cost de recursos baixíssim es pugui seguir l’estat de la tasca. Això ens evitaria la necessitat de que Gearman hagués de poder cridar un mètode de callback per informar-nos de l’estat de la mateixa, ja que hi ha alguns llenguatges en que fer això no és tan senzill.
En el gràfic que enganxo a continuació podem veure un esquema que he fet sobre això:
1) el nostre codi envia una tasca en ‘background’ (segon pla) a Gearman i aquest li torna un ‘Handler’ per identificar la tasca.
2) es guarda la tasca a Redis (set)
3) el nostre codi es subscriu al canal PubSub de la tasca
4) un worker demana la tasca
5) es publica l’estat de la tasca
6) es va actualitzant l’estat de la tasca
7) es van repetint els punts (5) i (6) fins acabar la tasca
Feedback
Com sempre s’accepten tota mena de crítiques i idees sobre la meva ‘paranoia’.