En ShareThis , no nos gusta crear trabajo extra para nosotros mismos. Administrar terabytes y petabytes de datos en tiempo real ya es bastante difícil. Como tal, buscamos agresivamente maneras de trabajar más rápido y más eficientemente. Esto significa evaluar diferentes tecnologías y automatizar tanto como sea posible. También implica prototipado rápido y conseguir las cosas y ejecutar con el menor código posible.

Recientemente, quería probar Azkaban para programar flujos de trabajo de forma rápida y sencilla. Sin embargo, no quería pasar mucho tiempo trayendo el sistema hacia arriba y hacia abajo durante las pruebas, y yo quería hacer un seguimiento de todos los cambios para que yo pudiera construir y destruir el sistema a voluntad. Esto sonaba como un buen momento para sacar mi Docker sombrero y uso Docker-componer. También me permitió cepillar el rizo de Bash.

El primer paso fue obtener un Dockerfile que configura una aplicación de nodo único. Esto me permitiría obtener un primer Go en el uso del 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

Entonces, el Docker-componga se podía utilizar para traer todo el asunto para arriba. Como tal, escribí un archivo DC-solo. yml:

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

Ahora puedo:

docker-compose -f dc-solo.yml build
docker-compost -f dc-solo.yml up

¡ Azkaban está corriendo! Jugué con la UI y me di cuenta de que si esto iba a funcionar, necesitaríamos tener flujos guardados en Github y auto-cargados. Esto me llevó a la segunda parte del proceso que iba a jugar con cómo obtener flujos de github a Azkaban. Para hacer esto, comencé a hackear su API usando Curl (nunca lo aconsejaría para un proyecto terminado, pero para iteración rápidamente, esto funciona). También llegué a conocer una buena herramienta JSON: JQ.

En primer lugar, vamos a escribir una función que guarda un token de sesión en una variable denominada FCRED:

#

getSession simply creates a session with default credentials.

#

getSession () {
  CRED=curl -k -X POST --data "action=login&username=azkaban&password=azkaban" $PROD
  mientras que [ $? -ne 0 ]
  hacer
        sueño 1
        CRED=curl -k -X POST --data "action=login&username=azkaban&password=azkaban" $PROD
  terminado
  FCRED=echo $CRED | jq '."session.id"' | sed s/\"//g
}

A continuación, vamos a crear un proyecto en 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
}

Puede subir un archivo zip con su flujo a su proyecto:

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
}

Incluso planificarlo:

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 "programación: $?"
  echo $RESP
  echo $RESP | jq '.''.
}

Terminé simplemente iteración a través del árbol de directorios, repasando los directorios que tenían archivos de trabajo de Azkaban y los cargaba.

#

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

Este no es el final. Estos flujos de Azkaban están demostrando ser útiles en una moda de MVP y he empezado a expandir la receta de composición de la base para que estemos respaldados por RDS de Amazon. ¿Ves cómo me estoy ahorrando trabajo por no implementar la DB? ¡ Me encanta la nube! Aquí está mi base de acoplamiento multi-nodo: (mi DC-Full. yml de trabajo para staging en un entorno local. Para utilizar RDS, reemplazo la imagen de la base de acoplamiento con una imagen de red real.)

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

Eso es todo por ahora. Vamos a ver si esto prueba en ShareThis y luego seguir iterando en él. Un día, podría funcionar con todos nuestros gasoductos automatizados. Si te gusta iteración rápidamente y los procesos de odio que obstruyen el tiempo de dev, entonces por favor ¡ Únase a nosotros!