No ShareThis, não gostamos de criar trabalho extra para nós mesmos. Gerir Terabytes e Petabytes de dados em tempo real já é bastante difícil. Como tal, procuramos agressivamente formas de trabalhar de forma mais rápida e eficiente. Isto significa avaliar diferentes tecnologias e automatizar o máximo possível. Também envolve prototipagem rápida e pôr as coisas a funcionar com o mínimo de código possível.

Recentemente, eu queria testar Azkaban para programar os fluxos de trabalho de forma rápida e fácil. Entretanto, eu não queria gastar muito tempo trazendo o sistema para cima e para baixo durante os testes, e eu queria acompanhar todas as mudanças para que eu pudesse construir e destruir o sistema à vontade. Este pareceu-me um óptimo momento para tirar o meu Docker chapéu e uso doca-composto. Também me permitiu escovar os caracóis de bash curl.

O primeiro passo foi conseguir um Dockerfile que monta uma aplicação de nó único. Isto permitir-me-ia uma primeira tentativa de usar o 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

Então, o "docker-compose" poderia ser usado para trazer a coisa toda para cima. Como tal, eu escrevi um ficheiro dc-solo.yml:

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

Agora eu posso :

$> docker-compose -f dc-solo.yml build
$> docker-compose -f dc-solo.yml up

Azkaban está a correr! Eu brinquei com a UI e percebi que, se isso fosse funcionar, precisaríamos ter fluxos salvos em Github e auto-carregados. Isso me levou à segunda parte do processo que era brincar com a forma de conseguir fluxos de Github para Azkaban. Para fazer isso, eu comecei a hackear as API's deles usando o curl (eu nunca aconselharia isso para um projeto terminado, mas para iterar rapidamente, isso funciona). Eu também conheci uma boa ferramenta json: "jq".

Primeiro, vamos escrever uma função que guarda um símbolo de sessão para uma variável chamada FCRED:

#

getSession simply creates a session with default credentials.

#

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

Então, vamos criar um projecto em 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
}

Você pode carregar um arquivo zip com o seu fluxo para o seu projeto:

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
}

Até mesmo agendá-lo:

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"
  echo "marcação: $?"
  echo $RESP
  echo $RESP | jq '.'
}

Acabei por fazer iterações através da árvore de directórios, zipando os directórios que tinham ficheiros de empregos Azkaban e fazendo o upload deles.

#

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
feito;

Isto não é o fim. Estes fluxos Azkaban estão se provando úteis de uma forma MVP e eu comecei a expandir a receita de composição da doca para que sejamos apoiados por RDS da amazônia. Você vê como eu estou me salvando ao não implementar o DB? Eu amo a nuvem!! Aqui está o meu multi-nó docker-compose: (meu dc-full.yml de trabalho para encenar em um ambiente local. Para usar o RDS, eu substituo a imagem do docker por uma imagem real da rede).

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

Por agora, é tudo. Vamos ver se isto se confirma no ShareThis e depois continuar a iterar sobre isto. Um dia, talvez funcione todos os nossos oleodutos automatizados. Se você gosta de iterar rapidamente e odeia processos que obstruem o tempo de desenvolvimento, então, por favor. junte-se a nós!