A ShareThis, non ci piace creare lavoro extra per noi stessi. Gestire Terabyte e Petabyte di dati in tempo reale è già abbastanza difficile. Per questo motivo, cerchiamo in modo aggressivo di lavorare in modo più rapido ed efficiente. Ciò significa valutare diverse tecnologie e automatizzare il più possibile. Ciò comporta anche la prototipazione rapida e la messa in funzione con il minor codice possibile.

Recentemente, ho voluto testare Azkaban per programmare i flussi di lavoro in modo semplice e veloce. Tuttavia, non volevo spendere molto tempo a portare il sistema su e giù durante i test, e volevo tenere traccia di tutti i cambiamenti in modo da poter costruire e distruggere il sistema a piacimento. Questo mi è sembrato un ottimo momento per tirare fuori il mio Docker cappello e uso docker-comporre. Mi ha anche permesso di rispolverare il bash curl.

Il primo passo è stato quello di ottenere un Dockerfile che configura un'applicazione a singolo nodo. Questo mi avrebbe permesso di ottenere un primo tentativo di utilizzare il sistema:

from java:7


COPY azkaban-solo-server-2.5.0.tar.gz /azkaban-solo-server-2.5.0.tar.gz
RUN tar -xf /azkaban-solo-server-2.5.0.tar.gz
RUN apt-get update
RUN apt-get install zip
ADD flows /azkaban-solo-2.5.0/flows
ADD run.sh /
ADD jq /usr/bin/jq


CMD /azkaban-solo-2.5.0/bin/azkaban-solo-start.sh

Poi, la docker-composizione potrebbe essere usata per portare tutto a galla. Come tale, ho scritto un file dc-solo.yml:

azkaban:
  build: solo/.
  ports:
        - 8081:8081

Ora posso:

$> docker-comporre -f dc-solo.yml costruire
$> docker-comporre -f dc-solo.yml up

Azkaban sta correndo! Ho giocato con l'interfaccia utente e mi sono reso conto che, per funzionare, avremmo dovuto salvare i flussi a Github e caricarli in automatico. Questo mi ha portato alla seconda parte del processo che consisteva nel giocare con i flussi da Github ad Azkaban. Per fare questo, ho iniziato ad hackerare le loro API usando il curl (non lo consiglierei mai per un progetto finito, ma per iterare velocemente, questo funziona). Ho anche avuto modo di conoscere un bel tool json: "jq".

Per prima cosa, scriviamo una funzione che salva un token di sessione su una variabile chiamata FCRED:

#

getSession simply creates a session with default credentials.

#

getSession () {
  CRED=curl -k -X POST --data "action=login&username=azkaban&password=azkaban" $PROD
  mentre [ $? -ne 0 ]
  fare
        dormire 1
        CRED=curl -k -X POST --data "action=login&username=azkaban&password=azkaban" $PROD
  fatto
  FCRED=echo $CRED | jq '."session.id"' | sed s/\"//g
}

Poi, creiamo un progetto ad Azkaban:

#

createProject creates a project in Azkaban

#

$1 The name of the project.

$2 The description of the project.

#

createProject () {
  RESP=curl -k -X POST --data "session.id=$FCRED&name=${1}&description=$2" $PROD/manager?action=create
}

Potete caricare un file zip con il vostro flusso nel vostro progetto:

uploadZip () {
  RESP=curl -k -H "Content-Type: multipart/mixed" -X POST --form "session.id=$1" --form "ajax=upload" --form "file=@$2;type=application/zip" --form "project=$3" $PROD/manager
  PROJECTID=echo $RESP | jq '.projectId' | sed s/\"//g
}

Anche programmarlo:

schedule () {
  RESP=curl -k "localhost:8081/schedule?ajax=scheduleFlow&session.id=$1&projectName=$2&flow=$3&projectId=$4&scheduleTime=$5&scheduleDate=$6&is_recurring=on&period=$7"
  eco "programmazione: $?
  echo $RESP
  echo $RESP | jq '.
}

Ho finito per iterare attraverso l'albero delle directory, zippare le directory che avevano i file di lavoro di Azkaban e caricarli.

#

uploadFlow will zip up the contents of each project directory and upload the flow.

#

$1 The name of the project which corresponds to a directory.

#

uploadFlow () {
  proj=$1
  rm $proj.zip
  zip $proj.zip $proj/*
  uploadZip $FCRED $proj.zip $proj
}

#

Main Script

#

getSession
for dir in ls -d */; do
  proj=${dir%%/}
  desc="cat ${dir}description.txt"
  createProject $proj "$desc".
  uploadFlow $proj
fatto;

Questa non è la fine. Questi flussi di Azkaban si stanno dimostrando utili in un modo MVP e ho iniziato ad ampliare la ricetta del docker-compose in modo che siamo supportati da RDS di Amazon. Vedete come mi sto risparmiando il lavoro non implementando il DB? Adoro la nuvola! Ecco il mio docker-composto multi-nodo: (il mio dc-full.yml funzionante per la messa in scena in un ambiente locale. Per usare RDS, sostituisco l'immagine docker con un'immagine di rete reale).

mysql:
  image: mysql
  environment:
        - MYSQLROOTPASSWORD=root
        - MYSQLDATABASE=azkaban
        - MYSQLUSER=azkaban
        - MYSQL_PASSWORD=azkaban
  volumes:
        - /mnt/mysql/azkaban:/var/lib/mysql
executor:
  build: exec/.
  links:
        - mysql
  ports:
        - 12321
web:
  build: web/.
  links:
        - mysql
        - executor
  ports:
        - 8081:8081

Per ora è tutto. Vedremo se questo si dimostrerà ShareThis e poi continueremo a iterare su di esso. Un giorno potrebbe far funzionare tutte le nostre condutture automatizzate. Se vi piace iterare velocemente e odiate i processi che intasano il tempo, allora per favore unisciti a noi!